/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow3Stride1 = WindowStrideTest<Pair, 3, 1>;
TYPED_TEST_SUITE(FilterBackpropWindow3Stride1, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {696.,  962., 732., 1112., 1496.,
                                         1112., 732., 962., 696.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {44.,  54.,  64.,  84., 94.,
                                         104., 124., 134., 144.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1338., 1392., 1846., 1924., 1401., 1464., 2128., 2224., 2856.,
      2992., 2116., 2224., 1374., 1464., 1798., 1924., 1293., 1392.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74.,  88.,  90.,  108., 106., 128.,
                                         138., 168., 154., 188., 170., 208.,
                                         202., 248., 218., 268., 234., 288.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2622., 2676., 2730., 2784., 3614., 3692., 3770., 3848., 2739.,
      2802., 2865., 2928., 4160., 4256., 4352., 4448., 5576., 5712.,
      5848., 5984., 4124., 4232., 4340., 4448., 2658., 2748., 2838.,
      2928., 3470., 3596., 3722., 3848., 2487., 2586., 2685., 2784.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      134., 148., 162., 176., 162., 180., 198., 216., 190., 212., 234., 256.,
      246., 276., 306., 336., 274., 308., 342., 376., 302., 340., 378., 416.,
      358., 404., 450., 496., 386., 436., 486., 536., 414., 468., 522., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1293., 1392., 1798., 1924., 1374., 1464., 2116., 2224., 2856.,
      2992., 2128., 2224., 1401., 1464., 1846., 1924., 1338., 1392.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78.,  88.,  98.,  108., 118., 128.,
                                         158., 168., 178., 188., 198., 208.,
                                         238., 248., 258., 268., 278., 288.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2487., 2586., 2676., 2784., 3452., 3596., 3692., 3848., 2631.,
      2748., 2802., 2928., 4052., 4232., 4256., 4448., 5456., 5712.,
      5712., 5984., 4052., 4256., 4232., 4448., 2631., 2802., 2748.,
      2928., 3452., 3692., 3596., 3848., 2487., 2676., 2586., 2784.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      132., 156., 148., 176., 164., 196., 180., 216., 196., 236., 212., 256.,
      260., 316., 276., 336., 292., 356., 308., 376., 324., 396., 340., 416.,
      388., 476., 404., 496., 420., 516., 436., 536., 452., 556., 468., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4875.,  4974.,  5073.,  5172.,  5244., 5352.,  5460.,  5568.,  6760.,
      6904.,  7048.,  7192.,  7228.,  7384., 7540.,  7696.,  5145.,  5262.,
      5379.,  5496.,  5478.,  5604.,  5730., 5856.,  7924.,  8104.,  8284.,
      8464.,  8320.,  8512.,  8704.,  8896., 10656., 10912., 11168., 11424.,
      11152., 11424., 11696., 11968., 7900., 8104.,  8308.,  8512.,  8248.,
      8464.,  8680.,  8896.,  5091.,  5262., 5433.,  5604.,  5316.,  5496.,
      5676.,  5856.,  6664.,  6904.,  7144., 7384.,  6940.,  7192.,  7444.,
      7696.,  4785.,  4974.,  5163.,  5352., 4974.,  5172.,  5370.,  5568.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  264.,  288., 312., 268.,  296., 324., 352., 296.,  328., 360.,
      392.,  324.,  360., 396., 432.,  352., 392., 432., 472.,  380., 424.,
      468.,  512.,  464., 520., 576.,  632., 492., 552., 612.,  672., 520.,
      584.,  648.,  712., 548., 616.,  684., 752., 576., 648.,  720., 792.,
      604.,  680.,  756., 832., 688.,  776., 864., 952., 716.,  808., 900.,
      992.,  744.,  840., 936., 1032., 772., 872., 972., 1072., 800., 904.,
      1008., 1112., 828., 936., 1044., 1152.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2487., 2586., 2685., 2784., 3470., 3596., 3722., 3848., 2658.,
      2748., 2838., 2928., 4124., 4232., 4340., 4448., 5576., 5712.,
      5848., 5984., 4160., 4256., 4352., 4448., 2739., 2802., 2865.,
      2928., 3614., 3692., 3770., 3848., 2622., 2676., 2730., 2784.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146., 156., 166., 176., 186., 196., 206., 216., 226., 236., 246., 256.,
      306., 316., 326., 336., 346., 356., 366., 376., 386., 396., 406., 416.,
      466., 476., 486., 496., 506., 516., 526., 536., 546., 556., 566., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4785.,  4974.,  4974.,  5172.,  5163., 5370.,  5352.,  5568.,  6664.,
      6940.,  6904.,  7192.,  7144.,  7444., 7384.,  7696.,  5091.,  5316.,
      5262.,  5496.,  5433.,  5676.,  5604., 5856.,  7900.,  8248.,  8104.,
      8464.,  8308.,  8680.,  8512.,  8896., 10656., 11152., 10912., 11424.,
      11168., 11696., 11424., 11968., 7924., 8320.,  8104.,  8512.,  8284.,
      8704.,  8464.,  8896.,  5145.,  5478., 5262.,  5604.,  5379.,  5730.,
      5496.,  5856.,  6760.,  7228.,  6904., 7384.,  7048.,  7540.,  7192.,
      7696.,  4875.,  5244.,  4974.,  5352., 5073.,  5460.,  5172.,  5568.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248., 292.,  264.,  312.,  280.,  332., 296.,  352., 312.,  372., 328.,
      392., 344.,  412.,  360.,  432.,  376., 452.,  392., 472.,  408., 492.,
      424., 512.,  504.,  612.,  520.,  632., 536.,  652., 552.,  672., 568.,
      692., 584.,  712.,  600.,  732.,  616., 752.,  632., 772.,  648., 792.,
      664., 812.,  680.,  832.,  760.,  932., 776.,  952., 792.,  972., 808.,
      992., 824.,  1012., 840.,  1032., 856., 1052., 872., 1072., 888., 1092.,
      904., 1112., 920.,  1132., 936.,  1152.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9381.,  9570.,  9759.,  9948.,  9750.,  9948.,  10146., 10344., 10119.,
      10326., 10533., 10740., 10488., 10704., 10920., 11136., 13052., 13328.,
      13604., 13880., 13520., 13808., 14096., 14384., 13988., 14288., 14588.,
      14888., 14456., 14768., 15080., 15392., 9957.,  10182., 10407., 10632.,
      10290., 10524., 10758., 10992., 10623., 10866., 11109., 11352., 10956.,
      11208., 11460., 11712., 15452., 15800., 16148., 16496., 15848., 16208.,
      16568., 16928., 16244., 16616., 16988., 17360., 16640., 17024., 17408.,
      17792., 20816., 21312., 21808., 22304., 21312., 21824., 22336., 22848.,
      21808., 22336., 22864., 23392., 22304., 22848., 23392., 23936., 15452.,
      15848., 16244., 16640., 15800., 16208., 16616., 17024., 16148., 16568.,
      16988., 17408., 16496., 16928., 17360., 17792., 9957.,  10290., 10623.,
      10956., 10182., 10524., 10866., 11208., 10407., 10758., 11109., 11460.,
      10632., 10992., 11352., 11712., 13052., 13520., 13988., 14456., 13328.,
      13808., 14288., 14768., 13604., 14096., 14588., 15080., 13880., 14384.,
      14888., 15392., 9381.,  9750.,  10119., 10488., 9570.,  9948.,  10326.,
      10704., 9759.,  10146., 10533., 10920., 9948.,  10344., 10740., 11136.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      452.,  496.,  540.,  584.,  480.,  528.,  576.,  624.,  508.,  560.,
      612.,  664.,  536.,  592.,  648.,  704.,  564.,  624.,  684.,  744.,
      592.,  656.,  720.,  784.,  620.,  688.,  756.,  824.,  648.,  720.,
      792.,  864.,  676.,  752.,  828.,  904.,  704.,  784.,  864.,  944.,
      732.,  816.,  900.,  984.,  760.,  848.,  936.,  1024., 900.,  1008.,
      1116., 1224., 928.,  1040., 1152., 1264., 956.,  1072., 1188., 1304.,
      984.,  1104., 1224., 1344., 1012., 1136., 1260., 1384., 1040., 1168.,
      1296., 1424., 1068., 1200., 1332., 1464., 1096., 1232., 1368., 1504.,
      1124., 1264., 1404., 1544., 1152., 1296., 1440., 1584., 1180., 1328.,
      1476., 1624., 1208., 1360., 1512., 1664., 1348., 1520., 1692., 1864.,
      1376., 1552., 1728., 1904., 1404., 1584., 1764., 1944., 1432., 1616.,
      1800., 1984., 1460., 1648., 1836., 2024., 1488., 1680., 1872., 2064.,
      1516., 1712., 1908., 2104., 1544., 1744., 1944., 2144., 1572., 1776.,
      1980., 2184., 1600., 1808., 2016., 2224., 1628., 1840., 2052., 2264.,
      1656., 1872., 2088., 2304.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1430., 1840., 1490., 2280., 2870.,
                                         2280., 1490., 1840., 1430.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {121., 142., 163., 226., 247.,
                                         268., 331., 352., 373.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2770., 2860., 3560., 3680., 2878., 2980., 4400., 4560., 5530.,
      5740., 4384., 4560., 2830., 2980., 3485., 3680., 2698., 2860.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {215., 242., 251., 284., 287., 326.,
                                         395., 452., 431., 494., 467., 536.,
                                         575., 662., 611., 704., 647., 746.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5450.,  5540.,  5630., 5720., 7000., 7120., 7240., 7360.,  5654.,
      5756.,  5858.,  5960., 8640., 8800., 8960., 9120., 10850., 11060.,
      11270., 11480., 8592., 8768., 8944., 9120., 5510., 5660.,  5810.,
      5960.,  6775.,  6970., 7165., 7360., 5234., 5396., 5558.,  5720.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      403.,  430.,  457.,  484.,  469.,  502.,  535.,  568.,  535.,
      574.,  613.,  652.,  733.,  790.,  847.,  904.,  799.,  862.,
      925.,  988.,  865.,  934.,  1003., 1072., 1063., 1150., 1237.,
      1324., 1129., 1222., 1315., 1408., 1195., 1294., 1393., 1492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2698., 2860., 3485., 3680., 2830., 2980., 4384., 4560., 5530.,
      5740., 4400., 4560., 2878., 2980., 3560., 3680., 2770., 2860.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {221., 242., 263., 284., 305., 326.,
                                         431., 452., 473., 494., 515., 536.,
                                         641., 662., 683., 704., 725., 746.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5228.,  5396.,  5540., 5720., 6745., 6970., 7120., 7360.,  5468.,
      5660.,  5756.,  5960., 8464., 8768., 8800., 9120., 10660., 11060.,
      11060., 11480., 8464., 8800., 8768., 9120., 5468., 5756.,  5660.,
      5960.,  6745.,  7120., 6970., 7360., 5228., 5540., 5396.,  5720.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      394.,  442.,  430.,  484.,  466.,  526.,  502.,  568.,  538.,
      610.,  574.,  652.,  754.,  862.,  790.,  904.,  826.,  946.,
      862.,  988.,  898.,  1030., 934.,  1072., 1114., 1282., 1150.,
      1324., 1186., 1366., 1222., 1408., 1258., 1450., 1294., 1492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10288., 10456., 10624., 10792., 10900., 11080., 11260., 11440., 13265.,
      13490., 13715., 13940., 14000., 14240., 14480., 14720., 10744., 10936.,
      11128., 11320., 11308., 11512., 11716., 11920., 16624., 16928., 17232.,
      17536., 17280., 17600., 17920., 18240., 20920., 21320., 21720., 22120.,
      21700., 22120., 22540., 22960., 16592., 16928., 17264., 17600., 17184.,
      17536., 17888., 18240., 10648., 10936., 11224., 11512., 11020., 11320.,
      11620., 11920., 13115., 13490., 13865., 14240., 13550., 13940., 14330.,
      14720., 10144., 10456., 10768., 11080., 10468., 10792., 11116., 11440.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      740.,  788.,  836.,  884.,  806.,  860.,  914.,  968.,  872.,
      932.,  992.,  1052., 938.,  1004., 1070., 1136., 1004., 1076.,
      1148., 1220., 1070., 1148., 1226., 1304., 1400., 1508., 1616.,
      1724., 1466., 1580., 1694., 1808., 1532., 1652., 1772., 1892.,
      1598., 1724., 1850., 1976., 1664., 1796., 1928., 2060., 1730.,
      1868., 2006., 2144., 2060., 2228., 2396., 2564., 2126., 2300.,
      2474., 2648., 2192., 2372., 2552., 2732., 2258., 2444., 2630.,
      2816., 2324., 2516., 2708., 2900., 2390., 2588., 2786., 2984.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5234.,  5396.,  5558., 5720., 6775., 6970., 7165., 7360.,  5510.,
      5660.,  5810.,  5960., 8592., 8768., 8944., 9120., 10850., 11060.,
      11270., 11480., 8640., 8800., 8960., 9120., 5654., 5756.,  5858.,
      5960.,  7000.,  7120., 7240., 7360., 5450., 5540., 5630.,  5720.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      421.,  442.,  463.,  484.,  505.,  526.,  547.,  568.,  589.,
      610.,  631.,  652.,  841.,  862.,  883.,  904.,  925.,  946.,
      967.,  988.,  1009., 1030., 1051., 1072., 1261., 1282., 1303.,
      1324., 1345., 1366., 1387., 1408., 1429., 1450., 1471., 1492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10144., 10468., 10456., 10792., 10768., 11116., 11080., 11440., 13115.,
      13550., 13490., 13940., 13865., 14330., 14240., 14720., 10648., 11020.,
      10936., 11320., 11224., 11620., 11512., 11920., 16592., 17184., 16928.,
      17536., 17264., 17888., 17600., 18240., 20920., 21700., 21320., 22120.,
      21720., 22540., 22120., 22960., 16624., 17280., 16928., 17600., 17232.,
      17920., 17536., 18240., 10744., 11308., 10936., 11512., 11128., 11716.,
      11320., 11920., 13265., 14000., 13490., 14240., 13715., 14480., 13940.,
      14720., 10288., 10900., 10456., 11080., 10624., 11260., 10792., 11440.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      752.,  842.,  788.,  884.,  824.,  926.,  860.,  968.,  896.,
      1010., 932.,  1052., 968.,  1094., 1004., 1136., 1040., 1178.,
      1076., 1220., 1112., 1262., 1148., 1304., 1472., 1682., 1508.,
      1724., 1544., 1766., 1580., 1808., 1616., 1850., 1652., 1892.,
      1688., 1934., 1724., 1976., 1760., 2018., 1796., 2060., 1832.,
      2102., 1868., 2144., 2192., 2522., 2228., 2564., 2264., 2606.,
      2300., 2648., 2336., 2690., 2372., 2732., 2408., 2774., 2444.,
      2816., 2480., 2858., 2516., 2900., 2552., 2942., 2588., 2984.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19964., 20288., 20612., 20936., 20576., 20912., 21248., 21584., 21188.,
      21536., 21884., 22232., 21800., 22160., 22520., 22880., 25795., 26230.,
      26665., 27100., 26530., 26980., 27430., 27880., 27265., 27730., 28195.,
      28660., 28000., 28480., 28960., 29440., 20924., 21296., 21668., 22040.,
      21488., 21872., 22256., 22640., 22052., 22448., 22844., 23240., 22616.,
      23024., 23432., 23840., 32592., 33184., 33776., 34368., 33248., 33856.,
      34464., 35072., 33904., 34528., 35152., 35776., 34560., 35200., 35840.,
      36480., 41060., 41840., 42620., 43400., 41840., 42640., 43440., 44240.,
      42620., 43440., 44260., 45080., 43400., 44240., 45080., 45920., 32592.,
      33248., 33904., 34560., 33184., 33856., 34528., 35200., 33776., 34464.,
      35152., 35840., 34368., 35072., 35776., 36480., 20924., 21488., 22052.,
      22616., 21296., 21872., 22448., 23024., 21668., 22256., 22844., 23432.,
      22040., 22640., 23240., 23840., 25795., 26530., 27265., 28000., 26230.,
      26980., 27730., 28480., 26665., 27430., 28195., 28960., 27100., 27880.,
      28660., 29440., 19964., 20576., 21188., 21800., 20288., 20912., 21536.,
      22160., 20612., 21248., 21884., 22520., 20936., 21584., 22232., 22880.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1414., 1504., 1594., 1684., 1480., 1576., 1672., 1768., 1546., 1648.,
      1750., 1852., 1612., 1720., 1828., 1936., 1678., 1792., 1906., 2020.,
      1744., 1864., 1984., 2104., 1810., 1936., 2062., 2188., 1876., 2008.,
      2140., 2272., 1942., 2080., 2218., 2356., 2008., 2152., 2296., 2440.,
      2074., 2224., 2374., 2524., 2140., 2296., 2452., 2608., 2734., 2944.,
      3154., 3364., 2800., 3016., 3232., 3448., 2866., 3088., 3310., 3532.,
      2932., 3160., 3388., 3616., 2998., 3232., 3466., 3700., 3064., 3304.,
      3544., 3784., 3130., 3376., 3622., 3868., 3196., 3448., 3700., 3952.,
      3262., 3520., 3778., 4036., 3328., 3592., 3856., 4120., 3394., 3664.,
      3934., 4204., 3460., 3736., 4012., 4288., 4054., 4384., 4714., 5044.,
      4120., 4456., 4792., 5128., 4186., 4528., 4870., 5212., 4252., 4600.,
      4948., 5296., 4318., 4672., 5026., 5380., 4384., 4744., 5104., 5464.,
      4450., 4816., 5182., 5548., 4516., 4888., 5260., 5632., 4582., 4960.,
      5338., 5716., 4648., 5032., 5416., 5800., 4714., 5104., 5494., 5884.,
      4780., 5176., 5572., 5968.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2550., 3135., 2640., 4060., 4900.,
                                         4060., 2640., 3135., 2550.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {256., 292., 328., 472., 508.,
                                         544., 688., 724., 760.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4965., 5100., 6099., 6270., 5130., 5280., 7880., 8120., 9500.,
      9800., 7860., 8120., 5055., 5280., 5991., 6270., 4860., 5100.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      468.,  512., 532.,  584.,  596.,  656.,  852.,  944.,  916.,
      1016., 980., 1088., 1236., 1376., 1300., 1448., 1364., 1520.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9795.,  9930.,  10065., 10200., 12027., 12198., 12369., 12540., 10110.,
      10260., 10410., 10560., 15520., 15760., 16000., 16240., 18700., 19000.,
      19300., 19600., 15460., 15720., 15980., 16240., 9885.,  10110., 10335.,
      10560., 11703., 11982., 12261., 12540., 9480.,  9720.,  9960.,  10200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      892.,  936.,  980.,  1024., 1012., 1064., 1116., 1168., 1132.,
      1192., 1252., 1312., 1612., 1704., 1796., 1888., 1732., 1832.,
      1932., 2032., 1852., 1960., 2068., 2176., 2332., 2472., 2612.,
      2752., 2452., 2600., 2748., 2896., 2572., 2728., 2884., 3040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4860., 5100., 5991., 6270., 5055., 5280., 7860., 8120., 9500.,
      9800., 7880., 8120., 5130., 5280., 6099., 6270., 4965., 5100.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      476.,  512.,  548.,  584.,  620.,  656.,  908.,  944.,  980.,
      1016., 1052., 1088., 1340., 1376., 1412., 1448., 1484., 1520.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9465.,  9720.,  9930.,  10200., 11658., 11982., 12198., 12540., 9825.,
      10110., 10260., 10560., 15260., 15720., 15760., 16240., 18424., 19000.,
      19000., 19600., 15260., 15760., 15720., 16240., 9825.,  10260., 10110.,
      10560., 11658., 12198., 11982., 12540., 9465.,  9930.,  9720.,  10200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      872.,  952.,  936.,  1024., 1000., 1096., 1064., 1168., 1128.,
      1240., 1192., 1312., 1640., 1816., 1704., 1888., 1768., 1960.,
      1832., 2032., 1896., 2104., 1960., 2176., 2408., 2680., 2472.,
      2752., 2536., 2824., 2600., 2896., 2664., 2968., 2728., 3040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18675., 18930., 19185., 19440., 19590., 19860., 20130., 20400., 22992.,
      23316., 23640., 23964., 24054., 24396., 24738., 25080., 19365., 19650.,
      19935., 20220., 20220., 20520., 20820., 21120., 30060., 30520., 30980.,
      31440., 31040., 31520., 32000., 32480., 36272., 36848., 37424., 38000.,
      37400., 38000., 38600., 39200., 30020., 30520., 31020., 31520., 30920.,
      31440., 31960., 32480., 19215., 19650., 20085., 20520., 19770., 20220.,
      20670., 21120., 22776., 23316., 23856., 24396., 23406., 23964., 24522.,
      25080., 18465., 18930., 19395., 19860., 18960., 19440., 19920., 20400.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1664., 1744., 1824., 1904., 1784., 1872., 1960., 2048., 1904.,
      2000., 2096., 2192., 2024., 2128., 2232., 2336., 2144., 2256.,
      2368., 2480., 2264., 2384., 2504., 2624., 3104., 3280., 3456.,
      3632., 3224., 3408., 3592., 3776., 3344., 3536., 3728., 3920.,
      3464., 3664., 3864., 4064., 3584., 3792., 4000., 4208., 3704.,
      3920., 4136., 4352., 4544., 4816., 5088., 5360., 4664., 4944.,
      5224., 5504., 4784., 5072., 5360., 5648., 4904., 5200., 5496.,
      5792., 5024., 5328., 5632., 5936., 5144., 5456., 5768., 6080.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9480.,  9720.,  9960.,  10200., 11703., 11982., 12261., 12540., 9885.,
      10110., 10335., 10560., 15460., 15720., 15980., 16240., 18700., 19000.,
      19300., 19600., 15520., 15760., 16000., 16240., 10110., 10260., 10410.,
      10560., 12027., 12198., 12369., 12540., 9795.,  9930.,  10065., 10200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      916.,  952.,  988.,  1024., 1060., 1096., 1132., 1168., 1204.,
      1240., 1276., 1312., 1780., 1816., 1852., 1888., 1924., 1960.,
      1996., 2032., 2068., 2104., 2140., 2176., 2644., 2680., 2716.,
      2752., 2788., 2824., 2860., 2896., 2932., 2968., 3004., 3040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18465., 18960., 18930., 19440., 19395., 19920., 19860., 20400., 22776.,
      23406., 23316., 23964., 23856., 24522., 24396., 25080., 19215., 19770.,
      19650., 20220., 20085., 20670., 20520., 21120., 30020., 30920., 30520.,
      31440., 31020., 31960., 31520., 32480., 36272., 37400., 36848., 38000.,
      37424., 38600., 38000., 39200., 30060., 31040., 30520., 31520., 30980.,
      32000., 31440., 32480., 19365., 20220., 19650., 20520., 19935., 20820.,
      20220., 21120., 22992., 24054., 23316., 24396., 23640., 24738., 23964.,
      25080., 18675., 19590., 18930., 19860., 19185., 20130., 19440., 20400.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1832., 1744., 1904., 1808., 1976., 1872., 2048., 1936.,
      2120., 2000., 2192., 2064., 2264., 2128., 2336., 2192., 2408.,
      2256., 2480., 2320., 2552., 2384., 2624., 3216., 3560., 3280.,
      3632., 3344., 3704., 3408., 3776., 3472., 3848., 3536., 3920.,
      3600., 3992., 3664., 4064., 3728., 4136., 3792., 4208., 3856.,
      4280., 3920., 4352., 4752., 5288., 4816., 5360., 4880., 5432.,
      4944., 5504., 5008., 5576., 5072., 5648., 5136., 5720., 5200.,
      5792., 5264., 5864., 5328., 5936., 5392., 6008., 5456., 6080.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36435., 36930., 37425., 37920., 37350., 37860., 38370., 38880., 38265.,
      38790., 39315., 39840., 39180., 39720., 40260., 40800., 44922., 45552.,
      46182., 46812., 45984., 46632., 47280., 47928., 47046., 47712., 48378.,
      49044., 48108., 48792., 49476., 50160., 37875., 38430., 38985., 39540.,
      38730., 39300., 39870., 40440., 39585., 40170., 40755., 41340., 40440.,
      41040., 41640., 42240., 59140., 60040., 60940., 61840., 60120., 61040.,
      61960., 62880., 61100., 62040., 62980., 63920., 62080., 63040., 64000.,
      64960., 71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400., 59140.,
      60120., 61100., 62080., 60040., 61040., 62040., 63040., 60940., 61960.,
      62980., 64000., 61840., 62880., 63920., 64960., 37875., 38730., 39585.,
      40440., 38430., 39300., 40170., 41040., 38985., 39870., 40755., 41640.,
      39540., 40440., 41340., 42240., 44922., 45984., 47046., 48108., 45552.,
      46632., 47712., 48792., 46182., 47280., 48378., 49476., 46812., 47928.,
      49044., 50160., 36435., 37350., 38265., 39180., 36930., 37860., 38790.,
      39720., 37425., 38370., 39315., 40260., 37920., 38880., 39840., 40800.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3208.,  3360.,  3512.,  3664.,  3328.,  3488.,  3648.,  3808.,  3448.,
      3616.,  3784.,  3952.,  3568.,  3744.,  3920.,  4096.,  3688.,  3872.,
      4056.,  4240.,  3808.,  4000.,  4192.,  4384.,  3928.,  4128.,  4328.,
      4528.,  4048.,  4256.,  4464.,  4672.,  4168.,  4384.,  4600.,  4816.,
      4288.,  4512.,  4736.,  4960.,  4408.,  4640.,  4872.,  5104.,  4528.,
      4768.,  5008.,  5248.,  6088.,  6432.,  6776.,  7120.,  6208.,  6560.,
      6912.,  7264.,  6328.,  6688.,  7048.,  7408.,  6448.,  6816.,  7184.,
      7552.,  6568.,  6944.,  7320.,  7696.,  6688.,  7072.,  7456.,  7840.,
      6808.,  7200.,  7592.,  7984.,  6928.,  7328.,  7728.,  8128.,  7048.,
      7456.,  7864.,  8272.,  7168.,  7584.,  8000.,  8416.,  7288.,  7712.,
      8136.,  8560.,  7408.,  7840.,  8272.,  8704.,  8968.,  9504.,  10040.,
      10576., 9088.,  9632.,  10176., 10720., 9208.,  9760.,  10312., 10864.,
      9328.,  9888.,  10448., 11008., 9448.,  10016., 10584., 11152., 9568.,
      10144., 10720., 11296., 9688.,  10272., 10856., 11440., 9808.,  10400.,
      10992., 11584., 9928.,  10528., 11128., 11728., 10048., 10656., 11264.,
      11872., 10168., 10784., 11400., 12016., 10288., 10912., 11536., 12160.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1496., 2040., 1544., 2140., 2870.,
                                         2140., 1544., 2040., 1496.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {149., 170., 191., 233., 254.,
                                         275., 317., 338., 359.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2896., 2992., 3944., 4080., 2980., 3088., 4130., 4280., 5530.,
      5740., 4115., 4280., 2944., 3088., 3880., 4080., 2836., 2992.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {265., 298., 301., 340., 337., 382.,
                                         409., 466., 445., 508., 481., 550.,
                                         553., 634., 589., 676., 625., 718.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5696.,  5792.,  5888., 5984., 7752., 7888., 8024., 8160.,  5852.,
      5960.,  6068.,  6176., 8110., 8260., 8410., 8560., 10850., 11060.,
      11270., 11480., 8065., 8230., 8395., 8560., 5744., 5888.,  6032.,
      6176.,  7560.,  7760., 7960., 8160., 5516., 5672., 5828.,  5984.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      497.,  530.,  563.,  596.,  563.,  602.,  641.,  680.,  629.,
      674.,  719.,  764.,  761.,  818.,  875.,  932.,  827.,  890.,
      953.,  1016., 893.,  962.,  1031., 1100., 1025., 1106., 1187.,
      1268., 1091., 1178., 1265., 1352., 1157., 1250., 1343., 1436.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2836., 2992., 3880., 4080., 2944., 3088., 4115., 4280., 5530.,
      5740., 4130., 4280., 2980., 3088., 3944., 4080., 2896., 2992.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {277., 298., 319., 340., 361., 382.,
                                         445., 466., 487., 508., 529., 550.,
                                         613., 634., 655., 676., 697., 718.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5492.,  5672.,  5792., 5984., 7504., 7760., 7888., 8160.,  5684.,
      5888.,  5960.,  6176., 7945., 8230., 8260., 8560., 10660., 11060.,
      11060., 11480., 7945., 8260., 8230., 8560., 5684., 5960.,  5888.,
      6176.,  7504.,  7888., 7760., 8160., 5492., 5792., 5672.,  5984.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      494.,  554.,  530.,  596.,  566.,  638.,  602.,  680.,  638.,
      722.,  674.,  764.,  782.,  890.,  818.,  932.,  854.,  974.,
      890.,  1016., 926.,  1058., 962.,  1100., 1070., 1226., 1106.,
      1268., 1142., 1310., 1178., 1352., 1214., 1394., 1250., 1436.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10804., 10984., 11164., 11344., 11392., 11584., 11776., 11968., 14752.,
      15008., 15264., 15520., 15504., 15776., 16048., 16320., 11164., 11368.,
      11572., 11776., 11704., 11920., 12136., 12352., 15605., 15890., 16175.,
      16460., 16220., 16520., 16820., 17120., 20920., 21320., 21720., 22120.,
      21700., 22120., 22540., 22960., 15575., 15890., 16205., 16520., 16130.,
      16460., 16790., 17120., 11092., 11368., 11644., 11920., 11488., 11776.,
      12064., 12352., 14624., 15008., 15392., 15776., 15120., 15520., 15920.,
      16320., 10684., 10984., 11284., 11584., 11032., 11344., 11656., 11968.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      928.,  988.,  1048., 1108., 994.,  1060., 1126., 1192., 1060.,
      1132., 1204., 1276., 1126., 1204., 1282., 1360., 1192., 1276.,
      1360., 1444., 1258., 1348., 1438., 1528., 1456., 1564., 1672.,
      1780., 1522., 1636., 1750., 1864., 1588., 1708., 1828., 1948.,
      1654., 1780., 1906., 2032., 1720., 1852., 1984., 2116., 1786.,
      1924., 2062., 2200., 1984., 2140., 2296., 2452., 2050., 2212.,
      2374., 2536., 2116., 2284., 2452., 2620., 2182., 2356., 2530.,
      2704., 2248., 2428., 2608., 2788., 2314., 2500., 2686., 2872.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5516.,  5672.,  5828., 5984., 7560., 7760., 7960., 8160.,  5744.,
      5888.,  6032.,  6176., 8065., 8230., 8395., 8560., 10850., 11060.,
      11270., 11480., 8110., 8260., 8410., 8560., 5852., 5960.,  6068.,
      6176.,  7752.,  7888., 8024., 8160., 5696., 5792., 5888.,  5984.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      533.,  554.,  575.,  596.,  617.,  638.,  659.,  680.,  701.,
      722.,  743.,  764.,  869.,  890.,  911.,  932.,  953.,  974.,
      995.,  1016., 1037., 1058., 1079., 1100., 1205., 1226., 1247.,
      1268., 1289., 1310., 1331., 1352., 1373., 1394., 1415., 1436.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10684., 11032., 10984., 11344., 11284., 11656., 11584., 11968., 14624.,
      15120., 15008., 15520., 15392., 15920., 15776., 16320., 11092., 11488.,
      11368., 11776., 11644., 12064., 11920., 12352., 15575., 16130., 15890.,
      16460., 16205., 16790., 16520., 17120., 20920., 21700., 21320., 22120.,
      21720., 22540., 22120., 22960., 15605., 16220., 15890., 16520., 16175.,
      16820., 16460., 17120., 11164., 11704., 11368., 11920., 11572., 12136.,
      11776., 12352., 14752., 15504., 15008., 15776., 15264., 16048., 15520.,
      16320., 10804., 11392., 10984., 11584., 11164., 11776., 11344., 11968.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      952.,  1066., 988.,  1108., 1024., 1150., 1060., 1192., 1096.,
      1234., 1132., 1276., 1168., 1318., 1204., 1360., 1240., 1402.,
      1276., 1444., 1312., 1486., 1348., 1528., 1528., 1738., 1564.,
      1780., 1600., 1822., 1636., 1864., 1672., 1906., 1708., 1948.,
      1744., 1990., 1780., 2032., 1816., 2074., 1852., 2116., 1888.,
      2158., 1924., 2200., 2104., 2410., 2140., 2452., 2176., 2494.,
      2212., 2536., 2248., 2578., 2284., 2620., 2320., 2662., 2356.,
      2704., 2392., 2746., 2428., 2788., 2464., 2830., 2500., 2872.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21020., 21368., 21716., 22064., 21608., 21968., 22328., 22688., 22196.,
      22568., 22940., 23312., 22784., 23168., 23552., 23936., 28752., 29248.,
      29744., 30240., 29504., 30016., 30528., 31040., 30256., 30784., 31312.,
      31840., 31008., 31552., 32096., 32640., 21788., 22184., 22580., 22976.,
      22328., 22736., 23144., 23552., 22868., 23288., 23708., 24128., 23408.,
      23840., 24272., 24704., 30595., 31150., 31705., 32260., 31210., 31780.,
      32350., 32920., 31825., 32410., 32995., 33580., 32440., 33040., 33640.,
      34240., 41060., 41840., 42620., 43400., 41840., 42640., 43440., 44240.,
      42620., 43440., 44260., 45080., 43400., 44240., 45080., 45920., 30595.,
      31210., 31825., 32440., 31150., 31780., 32410., 33040., 31705., 32350.,
      32995., 33640., 32260., 32920., 33580., 34240., 21788., 22328., 22868.,
      23408., 22184., 22736., 23288., 23840., 22580., 23144., 23708., 24272.,
      22976., 23552., 24128., 24704., 28752., 29504., 30256., 31008., 29248.,
      30016., 30784., 31552., 29744., 30528., 31312., 32096., 30240., 31040.,
      31840., 32640., 21020., 21608., 22196., 22784., 21368., 21968., 22568.,
      23168., 21716., 22328., 22940., 23552., 22064., 22688., 23312., 23936.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1790., 1904., 2018., 2132., 1856., 1976., 2096., 2216., 1922., 2048.,
      2174., 2300., 1988., 2120., 2252., 2384., 2054., 2192., 2330., 2468.,
      2120., 2264., 2408., 2552., 2186., 2336., 2486., 2636., 2252., 2408.,
      2564., 2720., 2318., 2480., 2642., 2804., 2384., 2552., 2720., 2888.,
      2450., 2624., 2798., 2972., 2516., 2696., 2876., 3056., 2846., 3056.,
      3266., 3476., 2912., 3128., 3344., 3560., 2978., 3200., 3422., 3644.,
      3044., 3272., 3500., 3728., 3110., 3344., 3578., 3812., 3176., 3416.,
      3656., 3896., 3242., 3488., 3734., 3980., 3308., 3560., 3812., 4064.,
      3374., 3632., 3890., 4148., 3440., 3704., 3968., 4232., 3506., 3776.,
      4046., 4316., 3572., 3848., 4124., 4400., 3902., 4208., 4514., 4820.,
      3968., 4280., 4592., 4904., 4034., 4352., 4670., 4988., 4100., 4424.,
      4748., 5072., 4166., 4496., 4826., 5156., 4232., 4568., 4904., 5240.,
      4298., 4640., 4982., 5324., 4364., 4712., 5060., 5408., 4430., 4784.,
      5138., 5492., 4496., 4856., 5216., 5576., 4562., 4928., 5294., 5660.,
      4628., 5000., 5372., 5744.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3080., 3920., 3160., 4400., 5525.,
                                         4400., 3160., 3920., 3080.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 456., 501., 636., 681.,
                                         726., 861., 906., 951.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6000.,  6160., 7630., 7840., 6144., 6320., 8550., 8800., 10725.,
      11050., 8530., 8800., 6080., 6320., 7530., 7840., 5904., 6160.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 1569., 1722., 1650., 1812., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11840., 12000., 12160., 12320., 15050., 15260., 15470., 15680., 12112.,
      12288., 12464., 12640., 16850., 17100., 17350., 17600., 21125., 21450.,
      21775., 22100., 16790., 17060., 17330., 17600., 11920., 12160., 12400.,
      12640., 14750., 15060., 15370., 15680., 11552., 11808., 12064., 12320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824., 1761.,
      1842., 1923., 2004., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 2985., 3138., 3291.,
      3444., 3138., 3300., 3462., 3624., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5904.,  6160., 7530., 7840., 6080., 6320., 8530., 8800., 10725.,
      11050., 8550., 8800., 6144., 6320., 7630., 7840., 6000., 6160.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      777.,  822.,  867.,  912.,  957.,  1002., 1227., 1272., 1317.,
      1362., 1407., 1452., 1677., 1722., 1767., 1812., 1857., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11504., 11808., 12000., 12320., 14660., 15060., 15260., 15680., 11824.,
      12160., 12288., 12640., 16580., 17060., 17100., 17600., 20825., 21450.,
      21450., 22100., 16580., 17100., 17060., 17600., 11824., 12288., 12160.,
      12640., 14660., 15260., 15060., 15680., 11504., 12000., 11808., 12320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1437., 1554., 1518., 1644., 1599., 1734., 1680., 1824., 1761.,
      1914., 1842., 2004., 2247., 2454., 2328., 2544., 2409., 2634.,
      2490., 2724., 2571., 2814., 2652., 2904., 3057., 3354., 3138.,
      3444., 3219., 3534., 3300., 3624., 3381., 3714., 3462., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22704., 23008., 23312., 23616., 23680., 24000., 24320., 24640., 28920.,
      29320., 29720., 30120., 30100., 30520., 30940., 31360., 23312., 23648.,
      23984., 24320., 24224., 24576., 24928., 25280., 32680., 33160., 33640.,
      34120., 33700., 34200., 34700., 35200., 41025., 41650., 42275., 42900.,
      42250., 42900., 43550., 44200., 32640., 33160., 33680., 34200., 33580.,
      34120., 34660., 35200., 23184., 23648., 24112., 24576., 23840., 24320.,
      24800., 25280., 28720., 29320., 29920., 30520., 29500., 30120., 30740.,
      31360., 22512., 23008., 23504., 24000., 23104., 23616., 24128., 24640.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757., 2874., 2991., 3108., 2910., 3036., 3162., 3288., 3063.,
      3198., 3333., 3468., 3216., 3360., 3504., 3648., 3369., 3522.,
      3675., 3828., 3522., 3684., 3846., 4008., 4287., 4494., 4701.,
      4908., 4440., 4656., 4872., 5088., 4593., 4818., 5043., 5268.,
      4746., 4980., 5214., 5448., 4899., 5142., 5385., 5628., 5052.,
      5304., 5556., 5808., 5817., 6114., 6411., 6708., 5970., 6276.,
      6582., 6888., 6123., 6438., 6753., 7068., 6276., 6600., 6924.,
      7248., 6429., 6762., 7095., 7428., 6582., 6924., 7266., 7608.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11552., 11808., 12064., 12320., 14750., 15060., 15370., 15680., 11920.,
      12160., 12400., 12640., 16790., 17060., 17330., 17600., 21125., 21450.,
      21775., 22100., 16850., 17100., 17350., 17600., 12112., 12288., 12464.,
      12640., 15050., 15260., 15470., 15680., 11840., 12000., 12160., 12320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1509., 1554., 1599., 1644., 1689., 1734., 1779., 1824., 1869.,
      1914., 1959., 2004., 2409., 2454., 2499., 2544., 2589., 2634.,
      2679., 2724., 2769., 2814., 2859., 2904., 3309., 3354., 3399.,
      3444., 3489., 3534., 3579., 3624., 3669., 3714., 3759., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22512., 23104., 23008., 23616., 23504., 24128., 24000., 24640., 28720.,
      29500., 29320., 30120., 29920., 30740., 30520., 31360., 23184., 23840.,
      23648., 24320., 24112., 24800., 24576., 25280., 32640., 33580., 33160.,
      34120., 33680., 34660., 34200., 35200., 41025., 42250., 41650., 42900.,
      42275., 43550., 42900., 44200., 32680., 33700., 33160., 34200., 33640.,
      34700., 34120., 35200., 23312., 24224., 23648., 24576., 23984., 24928.,
      24320., 25280., 28920., 30100., 29320., 30520., 29720., 30940., 30120.,
      31360., 22704., 23680., 23008., 24000., 23312., 24320., 23616., 24640.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2793., 3018., 2874., 3108., 2955., 3198., 3036., 3288., 3117.,
      3378., 3198., 3468., 3279., 3558., 3360., 3648., 3441., 3738.,
      3522., 3828., 3603., 3918., 3684., 4008., 4413., 4818., 4494.,
      4908., 4575., 4998., 4656., 5088., 4737., 5178., 4818., 5268.,
      4899., 5358., 4980., 5448., 5061., 5538., 5142., 5628., 5223.,
      5718., 5304., 5808., 6033., 6618., 6114., 6708., 6195., 6798.,
      6276., 6888., 6357., 6978., 6438., 7068., 6519., 7158., 6600.,
      7248., 6681., 7338., 6762., 7428., 6843., 7518., 6924., 7608.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44432., 45024., 45616., 46208., 45408., 46016., 46624., 47232., 46384.,
      47008., 47632., 48256., 47360., 48000., 48640., 49280., 56660., 57440.,
      58220., 59000., 57840., 58640., 59440., 60240., 59020., 59840., 60660.,
      61480., 60200., 61040., 61880., 62720., 45712., 46368., 47024., 47680.,
      46624., 47296., 47968., 48640., 47536., 48224., 48912., 49600., 48448.,
      49152., 49856., 50560., 64340., 65280., 66220., 67160., 65360., 66320.,
      67280., 68240., 66380., 67360., 68340., 69320., 67400., 68400., 69400.,
      70400., 80825., 82050., 83275., 84500., 82050., 83300., 84550., 85800.,
      83275., 84550., 85825., 87100., 84500., 85800., 87100., 88400., 64340.,
      65360., 66380., 67400., 65280., 66320., 67360., 68400., 66220., 67280.,
      68340., 69400., 67160., 68240., 69320., 70400., 45712., 46624., 47536.,
      48448., 46368., 47296., 48224., 49152., 47024., 47968., 48912., 49856.,
      47680., 48640., 49600., 50560., 56660., 57840., 59020., 60200., 57440.,
      58640., 59840., 61040., 58220., 59440., 60660., 61880., 59000., 60240.,
      61480., 62720., 44432., 45408., 46384., 47360., 45024., 46016., 47008.,
      48000., 45616., 46624., 47632., 48640., 46208., 47232., 48256., 49280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5586.,  5811.,  6036.,  5514.,  5748.,  5982.,  6216.,  5667.,
      5910.,  6153.,  6396.,  5820.,  6072.,  6324.,  6576.,  5973.,  6234.,
      6495.,  6756.,  6126.,  6396.,  6666.,  6936.,  6279.,  6558.,  6837.,
      7116.,  6432.,  6720.,  7008.,  7296.,  6585.,  6882.,  7179.,  7476.,
      6738.,  7044.,  7350.,  7656.,  6891.,  7206.,  7521.,  7836.,  7044.,
      7368.,  7692.,  8016.,  8421.,  8826.,  9231.,  9636.,  8574.,  8988.,
      9402.,  9816.,  8727.,  9150.,  9573.,  9996.,  8880.,  9312.,  9744.,
      10176., 9033.,  9474.,  9915.,  10356., 9186.,  9636.,  10086., 10536.,
      9339.,  9798.,  10257., 10716., 9492.,  9960.,  10428., 10896., 9645.,
      10122., 10599., 11076., 9798.,  10284., 10770., 11256., 9951.,  10446.,
      10941., 11436., 10104., 10608., 11112., 11616., 11481., 12066., 12651.,
      13236., 11634., 12228., 12822., 13416., 11787., 12390., 12993., 13596.,
      11940., 12552., 13164., 13776., 12093., 12714., 13335., 13956., 12246.,
      12876., 13506., 14136., 12399., 13038., 13677., 14316., 12552., 13200.,
      13848., 14496., 12705., 13362., 14019., 14676., 12858., 13524., 14190.,
      14856., 13011., 13686., 14361., 15036., 13164., 13848., 14532., 15216.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5500., 6700., 5620., 7850., 9455.,
                                         7850., 5620., 6700., 5500.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {870.,  948.,  1026., 1338., 1416.,
                                         1494., 1806., 1884., 1962.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10760., 11000., 13100., 13400., 10980., 11240., 15325., 15700., 18445.,
      18910., 15300., 15700., 10880., 11240., 12956., 13400., 10620., 11000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1638., 1740., 1782., 1896., 1926., 2052., 2502., 2676., 2646.,
      2832., 2790., 2988., 3366., 3612., 3510., 3768., 3654., 3924.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21280., 21520., 21760., 22000., 25900., 26200., 26500., 26800., 21700.,
      21960., 22220., 22480., 30275., 30650., 31025., 31400., 36425., 36890.,
      37355., 37820., 30200., 30600., 31000., 31400., 21400., 21760., 22120.,
      22480., 25468., 25912., 26356., 26800., 20860., 21240., 21620., 22000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3174., 3276., 3378., 3480., 3450., 3564., 3678., 3792., 3726.,
      3852., 3978., 4104., 4830., 5004., 5178., 5352., 5106., 5292.,
      5478., 5664., 5382., 5580., 5778., 5976., 6486., 6732., 6978.,
      7224., 6762., 7020., 7278., 7536., 7038., 7308., 7578., 7848.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10620., 11000., 12956., 13400., 10880., 11240., 15300., 15700., 18445.,
      18910., 15325., 15700., 10980., 11240., 13100., 13400., 10760., 11000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1662., 1740., 1818., 1896., 1974., 2052., 2598., 2676., 2754.,
      2832., 2910., 2988., 3534., 3612., 3690., 3768., 3846., 3924.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20780., 21240., 21520., 22000., 25336., 25912., 26200., 26800., 21260.,
      21760., 21960., 22480., 29875., 30600., 30650., 31400., 35990., 36890.,
      36890., 37820., 29875., 30650., 30600., 31400., 21260., 21960., 21760.,
      22480., 25336., 26200., 25912., 26800., 20780., 21520., 21240., 22000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3132., 3324., 3276., 3480., 3420., 3636., 3564., 3792., 3708.,
      3948., 3852., 4104., 4860., 5196., 5004., 5352., 5148., 5508.,
      5292., 5664., 5436., 5820., 5580., 5976., 6588., 7068., 6732.,
      7224., 6876., 7380., 7020., 7536., 7164., 7692., 7308., 7848.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41100., 41560., 42020., 42480., 42560., 43040., 43520., 44000., 50096.,
      50672., 51248., 51824., 51800., 52400., 53000., 53600., 42020., 42520.,
      43020., 43520., 43400., 43920., 44440., 44960., 59025., 59750., 60475.,
      61200., 60550., 61300., 62050., 62800., 71080., 71980., 72880., 73780.,
      72850., 73780., 74710., 75640., 58975., 59750., 60525., 61300., 60400.,
      61200., 62000., 62800., 41820., 42520., 43220., 43920., 42800., 43520.,
      44240., 44960., 49808., 50672., 51536., 52400., 50936., 51824., 52712.,
      53600., 40820., 41560., 42300., 43040., 41720., 42480., 43240., 44000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6072.,  6264.,  6456.,  6648.,  6348.,  6552.,  6756.,  6960.,  6624.,
      6840.,  7056.,  7272.,  6900.,  7128.,  7356.,  7584.,  7176.,  7416.,
      7656.,  7896.,  7452.,  7704.,  7956.,  8208.,  9384.,  9720.,  10056.,
      10392., 9660.,  10008., 10356., 10704., 9936.,  10296., 10656., 11016.,
      10212., 10584., 10956., 11328., 10488., 10872., 11256., 11640., 10764.,
      11160., 11556., 11952., 12696., 13176., 13656., 14136., 12972., 13464.,
      13956., 14448., 13248., 13752., 14256., 14760., 13524., 14040., 14556.,
      15072., 13800., 14328., 14856., 15384., 14076., 14616., 15156., 15696.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20860., 21240., 21620., 22000., 25468., 25912., 26356., 26800., 21400.,
      21760., 22120., 22480., 30200., 30600., 31000., 31400., 36425., 36890.,
      37355., 37820., 30275., 30650., 31025., 31400., 21700., 21960., 22220.,
      22480., 25900., 26200., 26500., 26800., 21280., 21520., 21760., 22000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3246., 3324., 3402., 3480., 3558., 3636., 3714., 3792., 3870.,
      3948., 4026., 4104., 5118., 5196., 5274., 5352., 5430., 5508.,
      5586., 5664., 5742., 5820., 5898., 5976., 6990., 7068., 7146.,
      7224., 7302., 7380., 7458., 7536., 7614., 7692., 7770., 7848.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40820., 41720., 41560., 42480., 42300., 43240., 43040., 44000., 49808.,
      50936., 50672., 51824., 51536., 52712., 52400., 53600., 41820., 42800.,
      42520., 43520., 43220., 44240., 43920., 44960., 58975., 60400., 59750.,
      61200., 60525., 62000., 61300., 62800., 71080., 72850., 71980., 73780.,
      72880., 74710., 73780., 75640., 59025., 60550., 59750., 61300., 60475.,
      62050., 61200., 62800., 42020., 43400., 42520., 43920., 43020., 44440.,
      43520., 44960., 50096., 51800., 50672., 52400., 51248., 53000., 51824.,
      53600., 41100., 42560., 41560., 43040., 42020., 43520., 42480., 44000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6120.,  6492.,  6264.,  6648.,  6408.,  6804.,  6552.,  6960.,  6696.,
      7116.,  6840.,  7272.,  6984.,  7428.,  7128.,  7584.,  7272.,  7740.,
      7416.,  7896.,  7560.,  8052.,  7704.,  8208.,  9576.,  10236., 9720.,
      10392., 9864.,  10548., 10008., 10704., 10152., 10860., 10296., 11016.,
      10440., 11172., 10584., 11328., 10728., 11484., 10872., 11640., 11016.,
      11796., 11160., 11952., 13032., 13980., 13176., 14136., 13320., 14292.,
      13464., 14448., 13608., 14604., 13752., 14760., 13896., 14916., 14040.,
      15072., 14184., 15228., 14328., 15384., 14472., 15540., 14616., 15696.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80740.,  81640.,  82540.,  83440.,  82200.,  83120.,  84040.,  84960.,
      83660.,  84600.,  85540.,  86480.,  85120.,  86080.,  87040.,  88000.,
      98488.,  99616.,  100744., 101872., 100192., 101344., 102496., 103648.,
      101896., 103072., 104248., 105424., 103600., 104800., 106000., 107200.,
      82660.,  83640.,  84620.,  85600.,  84040.,  85040.,  86040.,  87040.,
      85420.,  86440.,  87460.,  88480.,  86800.,  87840.,  88880.,  89920.,
      116525., 117950., 119375., 120800., 118050., 119500., 120950., 122400.,
      119575., 121050., 122525., 124000., 121100., 122600., 124100., 125600.,
      140390., 142160., 143930., 145700., 142160., 143960., 145760., 147560.,
      143930., 145760., 147590., 149420., 145700., 147560., 149420., 151280.,
      116525., 118050., 119575., 121100., 117950., 119500., 121050., 122600.,
      119375., 120950., 122525., 124100., 120800., 122400., 124000., 125600.,
      82660.,  84040.,  85420.,  86800.,  83640.,  85040.,  86440.,  87840.,
      84620.,  86040.,  87460.,  88880.,  85600.,  87040.,  88480.,  89920.,
      98488.,  100192., 101896., 103600., 99616.,  101344., 103072., 104800.,
      100744., 102496., 104248., 106000., 101872., 103648., 105424., 107200.,
      80740.,  82200.,  83660.,  85120.,  81640.,  83120.,  84600.,  86080.,
      82540.,  84040.,  85540.,  87040.,  83440.,  84960.,  86480.,  88000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11868., 12240., 12612., 12984., 12144., 12528., 12912., 13296., 12420.,
      12816., 13212., 13608., 12696., 13104., 13512., 13920., 12972., 13392.,
      13812., 14232., 13248., 13680., 14112., 14544., 13524., 13968., 14412.,
      14856., 13800., 14256., 14712., 15168., 14076., 14544., 15012., 15480.,
      14352., 14832., 15312., 15792., 14628., 15120., 15612., 16104., 14904.,
      15408., 15912., 16416., 18492., 19152., 19812., 20472., 18768., 19440.,
      20112., 20784., 19044., 19728., 20412., 21096., 19320., 20016., 20712.,
      21408., 19596., 20304., 21012., 21720., 19872., 20592., 21312., 22032.,
      20148., 20880., 21612., 22344., 20424., 21168., 21912., 22656., 20700.,
      21456., 22212., 22968., 20976., 21744., 22512., 23280., 21252., 22032.,
      22812., 23592., 21528., 22320., 23112., 23904., 25116., 26064., 27012.,
      27960., 25392., 26352., 27312., 28272., 25668., 26640., 27612., 28584.,
      25944., 26928., 27912., 28896., 26220., 27216., 28212., 29208., 26496.,
      27504., 28512., 29520., 26772., 27792., 28812., 29832., 27048., 28080.,
      29112., 30144., 27324., 28368., 29412., 30456., 27600., 28656., 29712.,
      30768., 27876., 28944., 30012., 31080., 28152., 29232., 30312., 31392.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2740., 3710., 2800., 3660., 4900.,
                                         3660., 2800., 3710., 2740.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {352., 388., 424., 496., 532.,
                                         568., 640., 676., 712.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5330., 5480., 7210., 7420., 5435., 5600., 7104., 7320., 9500.,
      9800., 7086., 7320., 5390., 5600., 7130., 7420., 5255., 5480.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      644.,  704.,  708.,  776.,  772.,  848.,  900.,  992.,  964.,
      1064., 1028., 1136., 1156., 1280., 1220., 1352., 1284., 1424.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10510., 10660., 10810., 10960., 14210., 14420., 14630., 14840., 10705.,
      10870., 11035., 11200., 13992., 14208., 14424., 14640., 18700., 19000.,
      19300., 19600., 13938., 14172., 14406., 14640., 10570., 10780., 10990.,
      11200., 13970., 14260., 14550., 14840., 10285., 10510., 10735., 10960.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1288., 1348., 1408., 1348., 1416., 1484., 1552., 1468.,
      1544., 1620., 1696., 1708., 1800., 1892., 1984., 1828., 1928.,
      2028., 2128., 1948., 2056., 2164., 2272., 2188., 2312., 2436.,
      2560., 2308., 2440., 2572., 2704., 2428., 2568., 2708., 2848.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5255., 5480., 7130., 7420., 5390., 5600., 7086., 7320., 9500.,
      9800., 7104., 7320., 5435., 5600., 7210., 7420., 5330., 5480.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      668.,  704.,  740.,  776.,  812.,  848.,  956.,  992.,  1028.,
      1064., 1100., 1136., 1244., 1280., 1316., 1352., 1388., 1424.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10225., 10510., 10660., 10960., 13860., 14260., 14420., 14840., 10465.,
      10780., 10870., 11200., 13758., 14172., 14208., 14640., 18424., 19000.,
      19000., 19600., 13758., 14208., 14172., 14640., 10465., 10870., 10780.,
      11200., 13860., 14420., 14260., 14840., 10225., 10660., 10510., 10960.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1224., 1336., 1288., 1408., 1352., 1480., 1416., 1552., 1480.,
      1624., 1544., 1696., 1736., 1912., 1800., 1984., 1864., 2056.,
      1928., 2128., 1992., 2200., 2056., 2272., 2248., 2488., 2312.,
      2560., 2376., 2632., 2440., 2704., 2504., 2776., 2568., 2848.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20165., 20450., 20735., 21020., 21020., 21320., 21620., 21920., 27320.,
      27720., 28120., 28520., 28420., 28840., 29260., 29680., 20615., 20930.,
      21245., 21560., 21410., 21740., 22070., 22400., 27102., 27516., 27930.,
      28344., 27984., 28416., 28848., 29280., 36272., 36848., 37424., 38000.,
      37400., 38000., 38600., 39200., 27066., 27516., 27966., 28416., 27876.,
      28344., 28812., 29280., 20525., 20930., 21335., 21740., 21140., 21560.,
      21980., 22400., 27160., 27720., 28280., 28840., 27940., 28520., 29100.,
      29680., 20015., 20450., 20885., 21320., 20570., 21020., 21470., 21920.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2336., 2448., 2560., 2672., 2456., 2576., 2696., 2816., 2576.,
      2704., 2832., 2960., 2696., 2832., 2968., 3104., 2816., 2960.,
      3104., 3248., 2936., 3088., 3240., 3392., 3296., 3472., 3648.,
      3824., 3416., 3600., 3784., 3968., 3536., 3728., 3920., 4112.,
      3656., 3856., 4056., 4256., 3776., 3984., 4192., 4400., 3896.,
      4112., 4328., 4544., 4256., 4496., 4736., 4976., 4376., 4624.,
      4872., 5120., 4496., 4752., 5008., 5264., 4616., 4880., 5144.,
      5408., 4736., 5008., 5280., 5552., 4856., 5136., 5416., 5696.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10285., 10510., 10735., 10960., 13970., 14260., 14550., 14840., 10570.,
      10780., 10990., 11200., 13938., 14172., 14406., 14640., 18700., 19000.,
      19300., 19600., 13992., 14208., 14424., 14640., 10705., 10870., 11035.,
      11200., 14210., 14420., 14630., 14840., 10510., 10660., 10810., 10960.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1300., 1336., 1372., 1408., 1444., 1480., 1516., 1552., 1588.,
      1624., 1660., 1696., 1876., 1912., 1948., 1984., 2020., 2056.,
      2092., 2128., 2164., 2200., 2236., 2272., 2452., 2488., 2524.,
      2560., 2596., 2632., 2668., 2704., 2740., 2776., 2812., 2848.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20015., 20570., 20450., 21020., 20885., 21470., 21320., 21920., 27160.,
      27940., 27720., 28520., 28280., 29100., 28840., 29680., 20525., 21140.,
      20930., 21560., 21335., 21980., 21740., 22400., 27066., 27876., 27516.,
      28344., 27966., 28812., 28416., 29280., 36272., 37400., 36848., 38000.,
      37424., 38600., 38000., 39200., 27102., 27984., 27516., 28416., 27930.,
      28848., 28344., 29280., 20615., 21410., 20930., 21740., 21245., 22070.,
      21560., 22400., 27320., 28420., 27720., 28840., 28120., 29260., 28520.,
      29680., 20165., 21020., 20450., 21320., 20735., 21620., 21020., 21920.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2384., 2600., 2448., 2672., 2512., 2744., 2576., 2816., 2640.,
      2888., 2704., 2960., 2768., 3032., 2832., 3104., 2896., 3176.,
      2960., 3248., 3024., 3320., 3088., 3392., 3408., 3752., 3472.,
      3824., 3536., 3896., 3600., 3968., 3664., 4040., 3728., 4112.,
      3792., 4184., 3856., 4256., 3920., 4328., 3984., 4400., 4048.,
      4472., 4112., 4544., 4432., 4904., 4496., 4976., 4560., 5048.,
      4624., 5120., 4688., 5192., 4752., 5264., 4816., 5336., 4880.,
      5408., 4944., 5480., 5008., 5552., 5072., 5624., 5136., 5696.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39475., 40030., 40585., 41140., 40330., 40900., 41470., 42040., 41185.,
      41770., 42355., 42940., 42040., 42640., 43240., 43840., 53540., 54320.,
      55100., 55880., 54640., 55440., 56240., 57040., 55740., 56560., 57380.,
      58200., 56840., 57680., 58520., 59360., 40435., 41050., 41665., 42280.,
      41230., 41860., 42490., 43120., 42025., 42670., 43315., 43960., 42820.,
      43480., 44140., 44800., 53322., 54132., 54942., 55752., 54204., 55032.,
      55860., 56688., 55086., 55932., 56778., 57624., 55968., 56832., 57696.,
      58560., 71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400., 53322.,
      54204., 55086., 55968., 54132., 55032., 55932., 56832., 54942., 55860.,
      56778., 57696., 55752., 56688., 57624., 58560., 40435., 41230., 42025.,
      42820., 41050., 41860., 42670., 43480., 41665., 42490., 43315., 44140.,
      42280., 43120., 43960., 44800., 53540., 54640., 55740., 56840., 54320.,
      55440., 56560., 57680., 55100., 56240., 57380., 58520., 55880., 57040.,
      58200., 59360., 39475., 40330., 41185., 42040., 40030., 40900., 41770.,
      42640., 40585., 41470., 42355., 43240., 41140., 42040., 42940., 43840.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4552.,  4768.,  4984.,  5200.,  4672.,  4896.,  5120.,  5344.,  4792.,
      5024.,  5256.,  5488.,  4912.,  5152.,  5392.,  5632.,  5032.,  5280.,
      5528.,  5776.,  5152.,  5408.,  5664.,  5920.,  5272.,  5536.,  5800.,
      6064.,  5392.,  5664.,  5936.,  6208.,  5512.,  5792.,  6072.,  6352.,
      5632.,  5920.,  6208.,  6496.,  5752.,  6048.,  6344.,  6640.,  5872.,
      6176.,  6480.,  6784.,  6472.,  6816.,  7160.,  7504.,  6592.,  6944.,
      7296.,  7648.,  6712.,  7072.,  7432.,  7792.,  6832.,  7200.,  7568.,
      7936.,  6952.,  7328.,  7704.,  8080.,  7072.,  7456.,  7840.,  8224.,
      7192.,  7584.,  7976.,  8368.,  7312.,  7712.,  8112.,  8512.,  7432.,
      7840.,  8248.,  8656.,  7552.,  7968.,  8384.,  8800.,  7672.,  8096.,
      8520.,  8944.,  7792.,  8224.,  8656.,  9088.,  8392.,  8864.,  9336.,
      9808.,  8512.,  8992.,  9472.,  9952.,  8632.,  9120.,  9608.,  10096.,
      8752.,  9248.,  9744.,  10240., 8872.,  9376.,  9880.,  10384., 8992.,
      9504.,  10016., 10528., 9112.,  9632.,  10152., 10672., 9232.,  9760.,
      10288., 10816., 9352.,  9888.,  10424., 10960., 9472.,  10016., 10560.,
      11104., 9592.,  10144., 10696., 11248., 9712.,  10272., 10832., 11392.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5650., 7150., 5750., 7540., 9455.,
                                         7540., 5750., 7150., 5650.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {974.,  1052., 1130., 1364., 1442.,
                                         1520., 1754., 1832., 1910.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11050., 11300., 13975., 14300., 11230., 11500., 14720., 15080., 18445.,
      18910., 14696., 15080., 11150., 11500., 13850., 14300., 10930., 11300.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1834., 1948., 1978., 2104., 2122., 2260., 2554., 2728., 2698.,
      2884., 2842., 3040., 3274., 3508., 3418., 3664., 3562., 3820.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21850., 22100., 22350., 22600., 27625., 27950., 28275., 28600., 22190.,
      22460., 22730., 23000., 29080., 29440., 29800., 30160., 36425., 36890.,
      37355., 37820., 29008., 29392., 29776., 30160., 21950., 22300., 22650.,
      23000., 27250., 27700., 28150., 28600., 21490., 21860., 22230., 22600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3554., 3668., 3782., 3896., 3830., 3956., 4082., 4208., 4106.,
      4244., 4382., 4520., 4934., 5108., 5282., 5456., 5210., 5396.,
      5582., 5768., 5486., 5684., 5882., 6080., 6314., 6548., 6782.,
      7016., 6590., 6836., 7082., 7328., 6866., 7124., 7382., 7640.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10930., 11300., 13850., 14300., 11150., 11500., 14696., 15080., 18445.,
      18910., 14720., 15080., 11230., 11500., 13975., 14300., 11050., 11300.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1870., 1948., 2026., 2104., 2182., 2260., 2650., 2728., 2806.,
      2884., 2962., 3040., 3430., 3508., 3586., 3664., 3742., 3820.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21380., 21860., 22100., 22600., 27075., 27700., 27950., 28600., 21780.,
      22300., 22460., 23000., 28696., 29392., 29440., 30160., 35990., 36890.,
      36890., 37820., 28696., 29440., 29392., 30160., 21780., 22460., 22300.,
      23000., 27075., 27950., 27700., 28600., 21380., 22100., 21860., 22600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3524., 3740., 3668., 3896., 3812., 4052., 3956., 4208., 4100.,
      4364., 4244., 4520., 4964., 5300., 5108., 5456., 5252., 5612.,
      5396., 5768., 5540., 5924., 5684., 6080., 6404., 6860., 6548.,
      7016., 6692., 7172., 6836., 7328., 6980., 7484., 7124., 7640.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42280., 42760., 43240., 43720., 43700., 44200., 44700., 45200., 53525.,
      54150., 54775., 55400., 55250., 55900., 56550., 57200., 43040., 43560.,
      44080., 44600., 44380., 44920., 45460., 46000., 56696., 57392., 58088.,
      58784., 58160., 58880., 59600., 60320., 71080., 71980., 72880., 73780.,
      72850., 73780., 74710., 75640., 56648., 57392., 58136., 58880., 58016.,
      58784., 59552., 60320., 42880., 43560., 44240., 44920., 43900., 44600.,
      45300., 46000., 53275., 54150., 55025., 55900., 54500., 55400., 56300.,
      57200., 42040., 42760., 43480., 44200., 42980., 43720., 44460., 45200.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6832.,  7048.,  7264.,  7480.,  7108.,  7336.,  7564.,  7792.,  7384.,
      7624.,  7864.,  8104.,  7660.,  7912.,  8164.,  8416.,  7936.,  8200.,
      8464.,  8728.,  8212.,  8488.,  8764.,  9040.,  9592.,  9928.,  10264.,
      10600., 9868.,  10216., 10564., 10912., 10144., 10504., 10864., 11224.,
      10420., 10792., 11164., 11536., 10696., 11080., 11464., 11848., 10972.,
      11368., 11764., 12160., 12352., 12808., 13264., 13720., 12628., 13096.,
      13564., 14032., 12904., 13384., 13864., 14344., 13180., 13672., 14164.,
      14656., 13456., 13960., 14464., 14968., 13732., 14248., 14764., 15280.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21490., 21860., 22230., 22600., 27250., 27700., 28150., 28600., 21950.,
      22300., 22650., 23000., 29008., 29392., 29776., 30160., 36425., 36890.,
      37355., 37820., 29080., 29440., 29800., 30160., 22190., 22460., 22730.,
      23000., 27625., 27950., 28275., 28600., 21850., 22100., 22350., 22600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3662., 3740., 3818., 3896., 3974., 4052., 4130., 4208., 4286.,
      4364., 4442., 4520., 5222., 5300., 5378., 5456., 5534., 5612.,
      5690., 5768., 5846., 5924., 6002., 6080., 6782., 6860., 6938.,
      7016., 7094., 7172., 7250., 7328., 7406., 7484., 7562., 7640.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42040., 42980., 42760., 43720., 43480., 44460., 44200., 45200., 53275.,
      54500., 54150., 55400., 55025., 56300., 55900., 57200., 42880., 43900.,
      43560., 44600., 44240., 45300., 44920., 46000., 56648., 58016., 57392.,
      58784., 58136., 59552., 58880., 60320., 71080., 72850., 71980., 73780.,
      72880., 74710., 73780., 75640., 56696., 58160., 57392., 58880., 58088.,
      59600., 58784., 60320., 43040., 44380., 43560., 44920., 44080., 45460.,
      44600., 46000., 53525., 55250., 54150., 55900., 54775., 56550., 55400.,
      57200., 42280., 43700., 42760., 44200., 43240., 44700., 43720., 45200.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6904.,  7324.,  7048.,  7480.,  7192.,  7636.,  7336.,  7792.,  7480.,
      7948.,  7624.,  8104.,  7768.,  8260.,  7912.,  8416.,  8056.,  8572.,
      8200.,  8728.,  8344.,  8884.,  8488.,  9040.,  9784.,  10444., 9928.,
      10600., 10072., 10756., 10216., 10912., 10360., 11068., 10504., 11224.,
      10648., 11380., 10792., 11536., 10936., 11692., 11080., 11848., 11224.,
      12004., 11368., 12160., 12664., 13564., 12808., 13720., 12952., 13876.,
      13096., 14032., 13240., 14188., 13384., 14344., 13528., 14500., 13672.,
      14656., 13816., 14812., 13960., 14968., 14104., 15124., 14248., 15280.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83140.,  84080.,  85020.,  85960.,  84560.,  85520.,  86480.,  87440.,
      85980.,  86960.,  87940.,  88920.,  87400.,  88400.,  89400.,  90400.,
      105325., 106550., 107775., 109000., 107050., 108300., 109550., 110800.,
      108775., 110050., 111325., 112600., 110500., 111800., 113100., 114400.,
      84740.,  85760.,  86780.,  87800.,  86080.,  87120.,  88160.,  89200.,
      87420.,  88480.,  89540.,  90600.,  88760.,  89840.,  90920.,  92000.,
      111928., 113296., 114664., 116032., 113392., 114784., 116176., 117568.,
      114856., 116272., 117688., 119104., 116320., 117760., 119200., 120640.,
      140390., 142160., 143930., 145700., 142160., 143960., 145760., 147560.,
      143930., 145760., 147590., 149420., 145700., 147560., 149420., 151280.,
      111928., 113392., 114856., 116320., 113296., 114784., 116272., 117760.,
      114664., 116176., 117688., 119200., 116032., 117568., 119104., 120640.,
      84740.,  86080.,  87420.,  88760.,  85760.,  87120.,  88480.,  89840.,
      86780.,  88160.,  89540.,  90920.,  87800.,  89200.,  90600.,  92000.,
      105325., 107050., 108775., 110500., 106550., 108300., 110050., 111800.,
      107775., 109550., 111325., 113100., 109000., 110800., 112600., 114400.,
      83140.,  84560.,  85980.,  87400.,  84080.,  85520.,  86960.,  88400.,
      85020.,  86480.,  87940.,  89400.,  85960.,  87440.,  88920.,  90400.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13388., 13808., 14228., 14648., 13664., 14096., 14528., 14960., 13940.,
      14384., 14828., 15272., 14216., 14672., 15128., 15584., 14492., 14960.,
      15428., 15896., 14768., 15248., 15728., 16208., 15044., 15536., 16028.,
      16520., 15320., 15824., 16328., 16832., 15596., 16112., 16628., 17144.,
      15872., 16400., 16928., 17456., 16148., 16688., 17228., 17768., 16424.,
      16976., 17528., 18080., 18908., 19568., 20228., 20888., 19184., 19856.,
      20528., 21200., 19460., 20144., 20828., 21512., 19736., 20432., 21128.,
      21824., 20012., 20720., 21428., 22136., 20288., 21008., 21728., 22448.,
      20564., 21296., 22028., 22760., 20840., 21584., 22328., 23072., 21116.,
      21872., 22628., 23384., 21392., 22160., 22928., 23696., 21668., 22448.,
      23228., 24008., 21944., 22736., 23528., 24320., 24428., 25328., 26228.,
      27128., 24704., 25616., 26528., 27440., 24980., 25904., 26828., 27752.,
      25256., 26192., 27128., 28064., 25532., 26480., 27428., 28376., 25808.,
      26768., 27728., 28688., 26084., 27056., 28028., 29000., 26360., 27344.,
      28328., 29312., 26636., 27632., 28628., 29624., 26912., 27920., 28928.,
      29936., 27188., 28208., 29228., 30248., 27464., 28496., 29528., 30560.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10100., 12245., 10250., 13470., 16206.,
                                         13470., 10250., 12245., 10100.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2064., 2200., 2336., 2880., 3016.,
                                         3152., 3696., 3832., 3968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19825., 20200., 24025., 24490., 20100., 20500., 26400., 26940., 31746.,
      32412., 26370., 26940., 19975., 20500., 23845., 24490., 19650., 20200.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3944., 4128., 4200., 4400., 4456., 4672., 5480., 5760., 5736.,
      6032., 5992., 6304., 7016., 7392., 7272., 7664., 7528., 7936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39275., 39650., 40025., 40400., 47585., 48050., 48515., 48980., 39800.,
      40200., 40600., 41000., 52260., 52800., 53340., 53880., 62826., 63492.,
      64158., 64824., 52170., 52740., 53310., 53880., 39425., 39950., 40475.,
      41000., 47045., 47690., 48335., 48980., 38750., 39300., 39850., 40400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7704.,  7888.,  8072.,  8256.,  8200.,  8400.,  8600.,  8800.,  8696.,
      8912.,  9128.,  9344.,  10680., 10960., 11240., 11520., 11176., 11472.,
      11768., 12064., 11672., 11984., 12296., 12608., 13656., 14032., 14408.,
      14784., 14152., 14544., 14936., 15328., 14648., 15056., 15464., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19650., 20200., 23845., 24490., 19975., 20500., 26370., 26940., 31746.,
      32412., 26400., 26940., 20100., 20500., 24025., 24490., 19825., 20200.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3992., 4128., 4264., 4400., 4536., 4672., 5624., 5760., 5896.,
      6032., 6168., 6304., 7256., 7392., 7528., 7664., 7800., 7936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38575., 39300., 39650., 40400., 46790., 47690., 48050., 48980., 39175.,
      39950., 40200., 41000., 51690., 52740., 52800., 53880., 62196., 63492.,
      63492., 64824., 51690., 52800., 52740., 53880., 39175., 40200., 39950.,
      41000., 46790., 48050., 47690., 48980., 38575., 39650., 39300., 40400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7632.,  7984.,  7888.,  8256.,  8144.,  8528.,  8400.,  8800.,  8656.,
      9072.,  8912.,  9344.,  10704., 11248., 10960., 11520., 11216., 11792.,
      11472., 12064., 11728., 12336., 11984., 12608., 13776., 14512., 14032.,
      14784., 14288., 15056., 14544., 15328., 14800., 15600., 15056., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76425.,  77150.,  77875.,  78600.,  78550.,  79300.,  80050.,  80800.,
      92680.,  93580.,  94480.,  95380.,  95170.,  96100.,  97030.,  97960.,
      77575.,  78350.,  79125.,  79900.,  79600.,  80400.,  81200.,  82000.,
      102330., 103380., 104430., 105480., 104520., 105600., 106680., 107760.,
      123096., 124392., 125688., 126984., 125652., 126984., 128316., 129648.,
      102270., 103380., 104490., 105600., 104340., 105480., 106620., 107760.,
      77325.,  78350.,  79375.,  80400.,  78850.,  79900.,  80950.,  82000.,
      92320.,  93580.,  94840.,  96100.,  94090.,  95380.,  96670.,  97960.,
      76075.,  77150.,  78225.,  79300.,  77500.,  78600.,  79700.,  80800.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14912., 15264., 15616., 15968., 15408., 15776., 16144., 16512., 15904.,
      16288., 16672., 17056., 16400., 16800., 17200., 17600., 16896., 17312.,
      17728., 18144., 17392., 17824., 18256., 18688., 20864., 21408., 21952.,
      22496., 21360., 21920., 22480., 23040., 21856., 22432., 23008., 23584.,
      22352., 22944., 23536., 24128., 22848., 23456., 24064., 24672., 23344.,
      23968., 24592., 25216., 26816., 27552., 28288., 29024., 27312., 28064.,
      28816., 29568., 27808., 28576., 29344., 30112., 28304., 29088., 29872.,
      30656., 28800., 29600., 30400., 31200., 29296., 30112., 30928., 31744.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38750., 39300., 39850., 40400., 47045., 47690., 48335., 48980., 39425.,
      39950., 40475., 41000., 52170., 52740., 53310., 53880., 62826., 63492.,
      64158., 64824., 52260., 52800., 53340., 53880., 39800., 40200., 40600.,
      41000., 47585., 48050., 48515., 48980., 39275., 39650., 40025., 40400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7848.,  7984.,  8120.,  8256.,  8392.,  8528.,  8664.,  8800.,  8936.,
      9072.,  9208.,  9344.,  11112., 11248., 11384., 11520., 11656., 11792.,
      11928., 12064., 12200., 12336., 12472., 12608., 14376., 14512., 14648.,
      14784., 14920., 15056., 15192., 15328., 15464., 15600., 15736., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76075.,  77500.,  77150.,  78600.,  78225.,  79700.,  79300.,  80800.,
      92320.,  94090.,  93580.,  95380.,  94840.,  96670.,  96100.,  97960.,
      77325.,  78850.,  78350.,  79900.,  79375.,  80950.,  80400.,  82000.,
      102270., 104340., 103380., 105480., 104490., 106620., 105600., 107760.,
      123096., 125652., 124392., 126984., 125688., 128316., 126984., 129648.,
      102330., 104520., 103380., 105600., 104430., 106680., 105480., 107760.,
      77575.,  79600.,  78350.,  80400.,  79125.,  81200.,  79900.,  82000.,
      92680.,  95170.,  93580.,  96100.,  94480.,  97030.,  95380.,  97960.,
      76425.,  78550.,  77150.,  79300.,  77875.,  80050.,  78600.,  80800.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15008., 15696., 15264., 15968., 15520., 16240., 15776., 16512., 16032.,
      16784., 16288., 17056., 16544., 17328., 16800., 17600., 17056., 17872.,
      17312., 18144., 17568., 18416., 17824., 18688., 21152., 22224., 21408.,
      22496., 21664., 22768., 21920., 23040., 22176., 23312., 22432., 23584.,
      22688., 23856., 22944., 24128., 23200., 24400., 23456., 24672., 23712.,
      24944., 23968., 25216., 27296., 28752., 27552., 29024., 27808., 29296.,
      28064., 29568., 28320., 29840., 28576., 30112., 28832., 30384., 29088.,
      30656., 29344., 30928., 29600., 31200., 29856., 31472., 30112., 31744.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150725., 152150., 153575., 155000., 152850., 154300., 155750., 157200.,
      154975., 156450., 157925., 159400., 157100., 158600., 160100., 161600.,
      182870., 184640., 186410., 188180., 185360., 187160., 188960., 190760.,
      187850., 189680., 191510., 193340., 190340., 192200., 194060., 195920.,
      153125., 154650., 156175., 157700., 155150., 156700., 158250., 159800.,
      157175., 158750., 160325., 161900., 159200., 160800., 162400., 164000.,
      202470., 204540., 206610., 208680., 204660., 206760., 208860., 210960.,
      206850., 208980., 211110., 213240., 209040., 211200., 213360., 215520.,
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.,
      202470., 204660., 206850., 209040., 204540., 206760., 208980., 211200.,
      206610., 208860., 211110., 213360., 208680., 210960., 213240., 215520.,
      153125., 155150., 157175., 159200., 154650., 156700., 158750., 160800.,
      156175., 158250., 160325., 162400., 157700., 159800., 161900., 164000.,
      182870., 185360., 187850., 190340., 184640., 187160., 189680., 192200.,
      186410., 188960., 191510., 194060., 188180., 190760., 193340., 195920.,
      150725., 152850., 154975., 157100., 152150., 154300., 156450., 158600.,
      153575., 155750., 157925., 160100., 155000., 157200., 159400., 161600.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29328., 30016., 30704., 31392., 29824., 30528., 31232., 31936., 30320.,
      31040., 31760., 32480., 30816., 31552., 32288., 33024., 31312., 32064.,
      32816., 33568., 31808., 32576., 33344., 34112., 32304., 33088., 33872.,
      34656., 32800., 33600., 34400., 35200., 33296., 34112., 34928., 35744.,
      33792., 34624., 35456., 36288., 34288., 35136., 35984., 36832., 34784.,
      35648., 36512., 37376., 41232., 42304., 43376., 44448., 41728., 42816.,
      43904., 44992., 42224., 43328., 44432., 45536., 42720., 43840., 44960.,
      46080., 43216., 44352., 45488., 46624., 43712., 44864., 46016., 47168.,
      44208., 45376., 46544., 47712., 44704., 45888., 47072., 48256., 45200.,
      46400., 47600., 48800., 45696., 46912., 48128., 49344., 46192., 47424.,
      48656., 49888., 46688., 47936., 49184., 50432., 53136., 54592., 56048.,
      57504., 53632., 55104., 56576., 58048., 54128., 55616., 57104., 58592.,
      54624., 56128., 57632., 59136., 55120., 56640., 58160., 59680., 55616.,
      57152., 58688., 60224., 56112., 57664., 59216., 60768., 56608., 58176.,
      59744., 61312., 57104., 58688., 60272., 61856., 57600., 59200., 60800.,
      62400., 58096., 59712., 61328., 62944., 58592., 60224., 61856., 63488.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20952., 28038., 21060., 28488., 38024.,
                                         28488., 21060., 28038., 20952.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2060., 2138., 2216., 2372., 2450.,
                                         2528., 2684., 2762., 2840.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41310., 41904., 55266., 56076., 41499., 42120., 56112., 56976., 74872.,
      76048., 56076., 56976., 41418., 42120., 55122., 56076., 41175., 41904.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3886., 4120., 4030., 4276., 4174., 4432., 4462., 4744., 4606.,
      4900., 4750., 5056., 5038., 5368., 5182., 5524., 5326., 5680.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      82026.,  82620.,  83214.,  83808.,  109722., 110532., 111342., 112152.,
      82377.,  82998.,  83619.,  84240.,  111360., 112224., 113088., 113952.,
      148568., 149744., 150920., 152096., 111252., 112152., 113052., 113952.,
      82134.,  82836.,  83538.,  84240.,  109290., 110244., 111198., 112152.,
      81621.,  82350.,  83079.,  83808.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7538.,  7772.,  8006.,  8240.,  7814.,  8060.,  8306.,  8552.,  8090.,
      8348.,  8606.,  8864.,  8642.,  8924.,  9206.,  9488.,  8918.,  9212.,
      9506.,  9800.,  9194.,  9500.,  9806.,  10112., 9746.,  10076., 10406.,
      10736., 10022., 10364., 10706., 11048., 10298., 10652., 11006., 11360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41175., 41904., 55122., 56076., 41418., 42120., 56076., 56976., 74872.,
      76048., 56112., 56976., 41499., 42120., 55266., 56076., 41310., 41904.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4042., 4120., 4198., 4276., 4354., 4432., 4666., 4744., 4822.,
      4900., 4978., 5056., 5290., 5368., 5446., 5524., 5602., 5680.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81189.,  82350.,  82620.,  83808.,  108660., 110244., 110532., 112152.,
      81621.,  82836.,  82998.,  84240.,  110460., 112152., 112224., 113952.,
      147440., 149744., 149744., 152096., 110460., 112224., 112152., 113952.,
      81621.,  82998.,  82836.,  84240.,  108660., 110532., 110244., 112152.,
      81189.,  82620.,  82350.,  83808.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7628.,  8084.,  7772.,  8240.,  7916.,  8396.,  8060.,  8552.,  8204.,
      8708.,  8348.,  8864.,  8780.,  9332.,  8924.,  9488.,  9068.,  9644.,
      9212.,  9800.,  9356.,  9956.,  9500.,  10112., 9932.,  10580., 10076.,
      10736., 10220., 10892., 10364., 11048., 10508., 11204., 10652., 11360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      161217., 162378., 163539., 164700., 164052., 165240., 166428., 167616.,
      215736., 217320., 218904., 220488., 219444., 221064., 222684., 224304.,
      162027., 163242., 164457., 165672., 164754., 165996., 167238., 168480.,
      219228., 220920., 222612., 224304., 222720., 224448., 226176., 227904.,
      292576., 294880., 297184., 299488., 297136., 299488., 301840., 304192.,
      219156., 220920., 222684., 224448., 222504., 224304., 226104., 227904.,
      161865., 163242., 164619., 165996., 164268., 165672., 167076., 168480.,
      215448., 217320., 219192., 221064., 218580., 220488., 222396., 224304.,
      160947., 162378., 163809., 165240., 163242., 164700., 166158., 167616.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14800., 15256., 15712., 16168., 15076., 15544., 16012., 16480., 15352.,
      15832., 16312., 16792., 15628., 16120., 16612., 17104., 15904., 16408.,
      16912., 17416., 16180., 16696., 17212., 17728., 17008., 17560., 18112.,
      18664., 17284., 17848., 18412., 18976., 17560., 18136., 18712., 19288.,
      17836., 18424., 19012., 19600., 18112., 18712., 19312., 19912., 18388.,
      19000., 19612., 20224., 19216., 19864., 20512., 21160., 19492., 20152.,
      20812., 21472., 19768., 20440., 21112., 21784., 20044., 20728., 21412.,
      22096., 20320., 21016., 21712., 22408., 20596., 21304., 22012., 22720.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81621.,  82350.,  83079.,  83808.,  109290., 110244., 111198., 112152.,
      82134.,  82836.,  83538.,  84240.,  111252., 112152., 113052., 113952.,
      148568., 149744., 150920., 152096., 111360., 112224., 113088., 113952.,
      82377.,  82998.,  83619.,  84240.,  109722., 110532., 111342., 112152.,
      82026.,  82620.,  83214.,  83808.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8006.,  8084.,  8162.,  8240.,  8318.,  8396.,  8474.,  8552.,  8630.,
      8708.,  8786.,  8864.,  9254.,  9332.,  9410.,  9488.,  9566.,  9644.,
      9722.,  9800.,  9878.,  9956.,  10034., 10112., 10502., 10580., 10658.,
      10736., 10814., 10892., 10970., 11048., 11126., 11204., 11282., 11360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      160947., 163242., 162378., 164700., 163809., 166158., 165240., 167616.,
      215448., 218580., 217320., 220488., 219192., 222396., 221064., 224304.,
      161865., 164268., 163242., 165672., 164619., 167076., 165996., 168480.,
      219156., 222504., 220920., 224304., 222684., 226104., 224448., 227904.,
      292576., 297136., 294880., 299488., 297184., 301840., 299488., 304192.,
      219228., 222720., 220920., 224448., 222612., 226176., 224304., 227904.,
      162027., 164754., 163242., 165996., 164457., 167238., 165672., 168480.,
      215736., 219444., 217320., 221064., 218904., 222684., 220488., 224304.,
      161217., 164052., 162378., 165240., 163539., 166428., 164700., 167616.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15112., 16012., 15256., 16168., 15400., 16324., 15544., 16480., 15688.,
      16636., 15832., 16792., 15976., 16948., 16120., 17104., 16264., 17260.,
      16408., 17416., 16552., 17572., 16696., 17728., 17416., 18508., 17560.,
      18664., 17704., 18820., 17848., 18976., 17992., 19132., 18136., 19288.,
      18280., 19444., 18424., 19600., 18568., 19756., 18712., 19912., 18856.,
      20068., 19000., 20224., 19720., 21004., 19864., 21160., 20008., 21316.,
      20152., 21472., 20296., 21628., 20440., 21784., 20584., 21940., 20728.,
      22096., 20872., 22252., 21016., 22408., 21160., 22564., 21304., 22720.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      319599., 321894., 324189., 326484., 322434., 324756., 327078., 329400.,
      325269., 327618., 329967., 332316., 328104., 330480., 332856., 335232.,
      427764., 430896., 434028., 437160., 431472., 434640., 437808., 440976.,
      435180., 438384., 441588., 444792., 438888., 442128., 445368., 448608.,
      321327., 323730., 326133., 328536., 324054., 326484., 328914., 331344.,
      326781., 329238., 331695., 334152., 329508., 331992., 334476., 336960.,
      434964., 438312., 441660., 445008., 438456., 441840., 445224., 448608.,
      441948., 445368., 448788., 452208., 445440., 448896., 452352., 455808.,
      580592., 585152., 589712., 594272., 585152., 589760., 594368., 598976.,
      589712., 594368., 599024., 603680., 594272., 598976., 603680., 608384.,
      434964., 438456., 441948., 445440., 438312., 441840., 445368., 448896.,
      441660., 445224., 448788., 452352., 445008., 448608., 452208., 455808.,
      321327., 324054., 326781., 329508., 323730., 326484., 329238., 331992.,
      326133., 328914., 331695., 334476., 328536., 331344., 334152., 336960.,
      427764., 431472., 435180., 438888., 430896., 434640., 438384., 442128.,
      434028., 437808., 441588., 445368., 437160., 440976., 444792., 448608.,
      319599., 322434., 325269., 328104., 321894., 324756., 327618., 330480.,
      324189., 327078., 329967., 332856., 326484., 329400., 332316., 335232.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29324., 30224., 31124., 32024., 29600., 30512., 31424., 32336., 29876.,
      30800., 31724., 32648., 30152., 31088., 32024., 32960., 30428., 31376.,
      32324., 33272., 30704., 31664., 32624., 33584., 30980., 31952., 32924.,
      33896., 31256., 32240., 33224., 34208., 31532., 32528., 33524., 34520.,
      31808., 32816., 33824., 34832., 32084., 33104., 34124., 35144., 32360.,
      33392., 34424., 35456., 33740., 34832., 35924., 37016., 34016., 35120.,
      36224., 37328., 34292., 35408., 36524., 37640., 34568., 35696., 36824.,
      37952., 34844., 35984., 37124., 38264., 35120., 36272., 37424., 38576.,
      35396., 36560., 37724., 38888., 35672., 36848., 38024., 39200., 35948.,
      37136., 38324., 39512., 36224., 37424., 38624., 39824., 36500., 37712.,
      38924., 40136., 36776., 38000., 39224., 40448., 38156., 39440., 40724.,
      42008., 38432., 39728., 41024., 42320., 38708., 40016., 41324., 42632.,
      38984., 40304., 41624., 42944., 39260., 40592., 41924., 43256., 39536.,
      40880., 42224., 43568., 39812., 41168., 42524., 43880., 40088., 41456.,
      42824., 44192., 40364., 41744., 43124., 44504., 40640., 42032., 43424.,
      44816., 40916., 42320., 43724., 45128., 41192., 42608., 44024., 45440.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43410., 54420., 43590., 59000., 73810.,
                                         59000., 43590., 54420., 43410.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5709., 5880., 6051., 6564., 6735.,
                                         6906., 7419., 7590., 7761.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      85830.,  86820.,  107580., 108840., 86154.,  87180.,
      116560., 118000., 145790., 147620., 116512., 118000.,
      86010.,  87180.,  107355., 108840., 85614.,  86820.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10977., 11418., 11301., 11760., 11625., 12102., 12597., 13128., 12921.,
      13470., 13245., 13812., 14217., 14838., 14541., 15180., 14865., 15522.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170670., 171660., 172650., 173640., 213900., 215160., 216420., 217680.,
      171282., 172308., 173334., 174360., 231680., 233120., 234560., 236000.,
      289750., 291580., 293410., 295240., 231536., 233024., 234512., 236000.,
      170850., 172020., 173190., 174360., 213225., 214710., 216195., 217680.,
      170022., 171228., 172434., 173640.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21513., 21954., 22395., 22836., 22143., 22602., 23061., 23520., 22773.,
      23250., 23727., 24204., 24663., 25194., 25725., 26256., 25293., 25842.,
      26391., 26940., 25923., 26490., 27057., 27624., 27813., 28434., 29055.,
      29676., 28443., 29082., 29721., 30360., 29073., 29730., 30387., 31044.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      85614.,  86820.,  107355., 108840., 86010.,  87180.,
      116512., 118000., 145790., 147620., 116560., 118000.,
      86154.,  87180.,  107580., 108840., 85830.,  86820.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11247., 11418., 11589., 11760., 11931., 12102., 12957., 13128., 13299.,
      13470., 13641., 13812., 14667., 14838., 15009., 15180., 15351., 15522.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      169284., 171228., 171660., 173640., 212235., 214710., 215160., 217680.,
      170004., 172020., 172308., 174360., 230192., 233024., 233120., 236000.,
      287980., 291580., 291580., 295240., 230192., 233120., 233024., 236000.,
      170004., 172308., 172020., 174360., 212235., 215160., 214710., 217680.,
      169284., 171660., 171228., 173640.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21630., 22494., 21954., 22836., 22278., 23178., 22602., 23520., 22926.,
      23862., 23250., 24204., 24870., 25914., 25194., 26256., 25518., 26598.,
      25842., 26940., 26166., 27282., 26490., 27624., 28110., 29334., 28434.,
      29676., 28758., 30018., 29082., 30360., 29406., 30702., 29730., 31044.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      336624., 338568., 340512., 342456., 341340., 343320., 345300., 347280.,
      421995., 424470., 426945., 429420., 427800., 430320., 432840., 435360.,
      337992., 340008., 342024., 344040., 342564., 344616., 346668., 348720.,
      457552., 460384., 463216., 466048., 463360., 466240., 469120., 472000.,
      572360., 575960., 579560., 583160., 579500., 583160., 586820., 590480.,
      457456., 460384., 463312., 466240., 463072., 466048., 469024., 472000.,
      337704., 340008., 342312., 344616., 341700., 344040., 346380., 348720.,
      421545., 424470., 427395., 430320., 426450., 429420., 432390., 435360.,
      336192., 338568., 340944., 343320., 340044., 342456., 344868., 347280.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42396., 43260., 44124., 44988., 43026., 43908., 44790., 45672., 43656.,
      44556., 45456., 46356., 44286., 45204., 46122., 47040., 44916., 45852.,
      46788., 47724., 45546., 46500., 47454., 48408., 48696., 49740., 50784.,
      51828., 49326., 50388., 51450., 52512., 49956., 51036., 52116., 53196.,
      50586., 51684., 52782., 53880., 51216., 52332., 53448., 54564., 51846.,
      52980., 54114., 55248., 54996., 56220., 57444., 58668., 55626., 56868.,
      58110., 59352., 56256., 57516., 58776., 60036., 56886., 58164., 59442.,
      60720., 57516., 58812., 60108., 61404., 58146., 59460., 60774., 62088.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170022., 171228., 172434., 173640., 213225., 214710., 216195., 217680.,
      170850., 172020., 173190., 174360., 231536., 233024., 234512., 236000.,
      289750., 291580., 293410., 295240., 231680., 233120., 234560., 236000.,
      171282., 172308., 173334., 174360., 213900., 215160., 216420., 217680.,
      170670., 171660., 172650., 173640.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22323., 22494., 22665., 22836., 23007., 23178., 23349., 23520., 23691.,
      23862., 24033., 24204., 25743., 25914., 26085., 26256., 26427., 26598.,
      26769., 26940., 27111., 27282., 27453., 27624., 29163., 29334., 29505.,
      29676., 29847., 30018., 30189., 30360., 30531., 30702., 30873., 31044.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      336192., 340044., 338568., 342456., 340944., 344868., 343320., 347280.,
      421545., 426450., 424470., 429420., 427395., 432390., 430320., 435360.,
      337704., 341700., 340008., 344040., 342312., 346380., 344616., 348720.,
      457456., 463072., 460384., 466048., 463312., 469024., 466240., 472000.,
      572360., 579500., 575960., 583160., 579560., 586820., 583160., 590480.,
      457552., 463360., 460384., 466240., 463216., 469120., 466048., 472000.,
      337992., 342564., 340008., 344616., 342024., 346668., 344040., 348720.,
      421995., 427800., 424470., 430320., 426945., 432840., 429420., 435360.,
      336624., 341340., 338568., 343320., 340512., 345300., 342456., 347280.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42936., 44646., 43260., 44988., 43584., 45330., 43908., 45672., 44232.,
      46014., 44556., 46356., 44880., 46698., 45204., 47040., 45528., 47382.,
      45852., 47724., 46176., 48066., 46500., 48408., 49416., 51486., 49740.,
      51828., 50064., 52170., 50388., 52512., 50712., 52854., 51036., 53196.,
      51360., 53538., 51684., 53880., 52008., 54222., 52332., 54564., 52656.,
      54906., 52980., 55248., 55896., 58326., 56220., 58668., 56544., 59010.,
      56868., 59352., 57192., 59694., 57516., 60036., 57840., 60378., 58164.,
      60720., 58488., 61062., 58812., 61404., 59136., 61746., 59460., 62088.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      668532.,  672384.,  676236.,  680088.,  673248.,  677136.,  681024.,
      684912.,  677964.,  681888.,  685812.,  689736.,  682680.,  686640.,
      690600.,  694560.,  838185.,  843090.,  847995.,  852900.,  843990.,
      848940.,  853890.,  858840.,  849795.,  854790.,  859785.,  864780.,
      855600.,  860640.,  865680.,  870720.,  671412.,  675408.,  679404.,
      683400.,  675984.,  680016.,  684048.,  688080.,  680556.,  684624.,
      688692.,  692760.,  685128.,  689232.,  693336.,  697440.,  909296.,
      914912.,  920528.,  926144.,  915104.,  920768.,  926432.,  932096.,
      920912.,  926624.,  932336.,  938048.,  926720.,  932480.,  938240.,
      944000.,  1137580., 1144720., 1151860., 1159000., 1144720., 1151920.,
      1159120., 1166320., 1151860., 1159120., 1166380., 1173640., 1159000.,
      1166320., 1173640., 1180960., 909296.,  915104.,  920912.,  926720.,
      914912.,  920768.,  926624.,  932480.,  920528.,  926432.,  932336.,
      938240.,  926144.,  932096.,  938048.,  944000.,  671412.,  675984.,
      680556.,  685128.,  675408.,  680016.,  684624.,  689232.,  679404.,
      684048.,  688692.,  693336.,  683400.,  688080.,  692760.,  697440.,
      838185.,  843990.,  849795.,  855600.,  843090.,  848940.,  854790.,
      860640.,  847995.,  853890.,  859785.,  865680.,  852900.,  858840.,
      864780.,  870720.,  668532.,  673248.,  677964.,  682680.,  672384.,
      677136.,  681888.,  686640.,  676236.,  681024.,  685812.,  690600.,
      680088.,  684912.,  689736.,  694560.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84162.,  85872.,  87582.,  89292.,  84792.,  86520.,  88248.,  89976.,
      85422.,  87168.,  88914.,  90660.,  86052.,  87816.,  89580.,  91344.,
      86682.,  88464.,  90246.,  92028.,  87312.,  89112.,  90912.,  92712.,
      87942.,  89760.,  91578.,  93396.,  88572.,  90408.,  92244.,  94080.,
      89202.,  91056.,  92910.,  94764.,  89832.,  91704.,  93576.,  95448.,
      90462.,  92352.,  94242.,  96132.,  91092.,  93000.,  94908.,  96816.,
      96762.,  98832.,  100902., 102972., 97392.,  99480.,  101568., 103656.,
      98022.,  100128., 102234., 104340., 98652.,  100776., 102900., 105024.,
      99282.,  101424., 103566., 105708., 99912.,  102072., 104232., 106392.,
      100542., 102720., 104898., 107076., 101172., 103368., 105564., 107760.,
      101802., 104016., 106230., 108444., 102432., 104664., 106896., 109128.,
      103062., 105312., 107562., 109812., 103692., 105960., 108228., 110496.,
      109362., 111792., 114222., 116652., 109992., 112440., 114888., 117336.,
      110622., 113088., 115554., 118020., 111252., 113736., 116220., 118704.,
      111882., 114384., 116886., 119388., 112512., 115032., 117552., 120072.,
      113142., 115680., 118218., 120756., 113772., 116328., 118884., 121440.,
      114402., 116976., 119550., 122124., 115032., 117624., 120216., 122808.,
      115662., 118272., 120882., 123492., 116292., 118920., 121548., 124176.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {77850.,  93645.,  78120.,
                                         105780., 127020., 105780.,
                                         78120.,  93645.,  77850.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12096., 12396., 12696., 13896., 14196.,
                                         14496., 15696., 15996., 16296.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154215., 155700., 185481., 187290., 154710., 156240.,
      209400., 211560., 251412., 254040., 209340., 211560.,
      154485., 156240., 185157., 187290., 153900., 155700.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23484., 24192., 24060., 24792., 24636., 25392., 26940., 27792., 27516.,
      28392., 28092., 28992., 30396., 31392., 30972., 31992., 31548., 32592.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306945., 308430., 309915., 311400., 369153., 370962., 372771., 374580.,
      307890., 309420., 310950., 312480., 416640., 418800., 420960., 423120.,
      500196., 502824., 505452., 508080., 416460., 418680., 420900., 423120.,
      307215., 308970., 310725., 312480., 368181., 370314., 372447., 374580.,
      306000., 307800., 309600., 311400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46260., 46968., 47676., 48384., 47388., 48120., 48852., 49584., 48516.,
      49272., 50028., 50784., 53028., 53880., 54732., 55584., 54156., 55032.,
      55908., 56784., 55284., 56184., 57084., 57984., 59796., 60792., 61788.,
      62784., 60924., 61944., 62964., 63984., 62052., 63096., 64140., 65184.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      153900., 155700., 185157., 187290., 154485., 156240.,
      209340., 211560., 251412., 254040., 209400., 211560.,
      154710., 156240., 185481., 187290., 154215., 155700.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23892., 24192., 24492., 24792., 25092., 25392., 27492., 27792., 28092.,
      28392., 28692., 28992., 31092., 31392., 31692., 31992., 32292., 32592.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      304875., 307800., 308430., 311400., 366750., 370314., 370962., 374580.,
      305955., 308970., 309420., 312480., 414420., 418680., 418800., 423120.,
      497640., 502824., 502824., 508080., 414420., 418800., 418680., 423120.,
      305955., 309420., 308970., 312480., 366750., 370962., 370314., 374580.,
      304875., 308430., 307800., 311400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46392., 47784., 46968., 48384., 47544., 48984., 48120., 49584., 48696.,
      50184., 49272., 50784., 53304., 54984., 53880., 55584., 54456., 56184.,
      55032., 56784., 55608., 57384., 56184., 57984., 60216., 62184., 60792.,
      62784., 61368., 63384., 61944., 63984., 62520., 64584., 63096., 65184.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      606825.,  609750.,  612675.,  615600.,  613890.,  616860., 619830.,
      622800.,  729936.,  733500.,  737064.,  740628.,  738306., 741924.,
      745542.,  749160.,  608895.,  611910.,  614925.,  617940., 615780.,
      618840.,  621900.,  624960.,  824580.,  828840.,  833100., 837360.,
      833280.,  837600.,  841920.,  846240.,  990096.,  995280., 1000464.,
      1005648., 1000392., 1005648., 1010904., 1016160., 824460., 828840.,
      833220.,  837600.,  832920.,  837360.,  841800.,  846240., 608445.,
      611910.,  615375.,  618840.,  614430.,  617940.,  621450., 624960.,
      729288.,  733500.,  737712.,  741924.,  736362.,  740628., 744894.,
      749160.,  606195.,  609750.,  613305.,  616860.,  612000., 615600.,
      619200.,  622800.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91392.,  92784.,  94176.,  95568.,  92520.,  93936.,  95352.,  96768.,
      93648.,  95088.,  96528.,  97968.,  94776.,  96240.,  97704.,  99168.,
      95904.,  97392.,  98880.,  100368., 97032.,  98544.,  100056., 101568.,
      104928., 106608., 108288., 109968., 106056., 107760., 109464., 111168.,
      107184., 108912., 110640., 112368., 108312., 110064., 111816., 113568.,
      109440., 111216., 112992., 114768., 110568., 112368., 114168., 115968.,
      118464., 120432., 122400., 124368., 119592., 121584., 123576., 125568.,
      120720., 122736., 124752., 126768., 121848., 123888., 125928., 127968.,
      122976., 125040., 127104., 129168., 124104., 126192., 128280., 130368.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306000., 307800., 309600., 311400., 368181., 370314., 372447., 374580.,
      307215., 308970., 310725., 312480., 416460., 418680., 420900., 423120.,
      500196., 502824., 505452., 508080., 416640., 418800., 420960., 423120.,
      307890., 309420., 310950., 312480., 369153., 370962., 372771., 374580.,
      306945., 308430., 309915., 311400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47484., 47784., 48084., 48384., 48684., 48984., 49284., 49584., 49884.,
      50184., 50484., 50784., 54684., 54984., 55284., 55584., 55884., 56184.,
      56484., 56784., 57084., 57384., 57684., 57984., 61884., 62184., 62484.,
      62784., 63084., 63384., 63684., 63984., 64284., 64584., 64884., 65184.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      606195.,  612000.,  609750.,  615600.,  613305.,  619200.,  616860.,
      622800.,  729288.,  736362.,  733500.,  740628.,  737712.,  744894.,
      741924.,  749160.,  608445.,  614430.,  611910.,  617940.,  615375.,
      621450.,  618840.,  624960.,  824460.,  832920.,  828840.,  837360.,
      833220.,  841800.,  837600.,  846240.,  990096.,  1000392., 995280.,
      1005648., 1000464., 1010904., 1005648., 1016160., 824580.,  833280.,
      828840.,  837600.,  833100.,  841920.,  837360.,  846240.,  608895.,
      615780.,  611910.,  618840.,  614925.,  621900.,  617940.,  624960.,
      729936.,  738306.,  733500.,  741924.,  737064.,  745542.,  740628.,
      749160.,  606825.,  613890.,  609750.,  616860.,  612675.,  619830.,
      615600.,  622800.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92208.,  94968.,  92784.,  95568.,  93360.,  96168.,  93936.,  96768.,
      94512.,  97368.,  95088.,  97968.,  95664.,  98568.,  96240.,  99168.,
      96816.,  99768.,  97392.,  100368., 97968.,  100968., 98544.,  101568.,
      106032., 109368., 106608., 109968., 107184., 110568., 107760., 111168.,
      108336., 111768., 108912., 112368., 109488., 112968., 110064., 113568.,
      110640., 114168., 111216., 114768., 111792., 115368., 112368., 115968.,
      119856., 123768., 120432., 124368., 121008., 124968., 121584., 125568.,
      122160., 126168., 122736., 126768., 123312., 127368., 123888., 127968.,
      124464., 128568., 125040., 129168., 125616., 129768., 126192., 130368.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1206585., 1212390., 1218195., 1224000., 1213650., 1219500., 1225350.,
      1231200., 1220715., 1226610., 1232505., 1238400., 1227780., 1233720.,
      1239660., 1245600., 1451502., 1458576., 1465650., 1472724., 1459872.,
      1467000., 1474128., 1481256., 1468242., 1475424., 1482606., 1489788.,
      1476612., 1483848., 1491084., 1498320., 1210905., 1216890., 1222875.,
      1228860., 1217790., 1223820., 1229850., 1235880., 1224675., 1230750.,
      1236825., 1242900., 1231560., 1237680., 1243800., 1249920., 1640460.,
      1648920., 1657380., 1665840., 1649160., 1657680., 1666200., 1674720.,
      1657860., 1666440., 1675020., 1683600., 1666560., 1675200., 1683840.,
      1692480., 1969896., 1980192., 1990488., 2000784., 1980192., 1990560.,
      2000928., 2011296., 1990488., 2000928., 2011368., 2021808., 2000784.,
      2011296., 2021808., 2032320., 1640460., 1649160., 1657860., 1666560.,
      1648920., 1657680., 1666440., 1675200., 1657380., 1666200., 1675020.,
      1683840., 1665840., 1674720., 1683600., 1692480., 1210905., 1217790.,
      1224675., 1231560., 1216890., 1223820., 1230750., 1237680., 1222875.,
      1229850., 1236825., 1243800., 1228860., 1235880., 1242900., 1249920.,
      1451502., 1459872., 1468242., 1476612., 1458576., 1467000., 1475424.,
      1483848., 1465650., 1474128., 1482606., 1491084., 1472724., 1481256.,
      1489788., 1498320., 1206585., 1213650., 1220715., 1227780., 1212390.,
      1219500., 1226610., 1233720., 1218195., 1225350., 1232505., 1239660.,
      1224000., 1231200., 1238400., 1245600.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181656., 184416., 187176., 189936., 182784., 185568., 188352., 191136.,
      183912., 186720., 189528., 192336., 185040., 187872., 190704., 193536.,
      186168., 189024., 191880., 194736., 187296., 190176., 193056., 195936.,
      188424., 191328., 194232., 197136., 189552., 192480., 195408., 198336.,
      190680., 193632., 196584., 199536., 191808., 194784., 197760., 200736.,
      192936., 195936., 198936., 201936., 194064., 197088., 200112., 203136.,
      208728., 212064., 215400., 218736., 209856., 213216., 216576., 219936.,
      210984., 214368., 217752., 221136., 212112., 215520., 218928., 222336.,
      213240., 216672., 220104., 223536., 214368., 217824., 221280., 224736.,
      215496., 218976., 222456., 225936., 216624., 220128., 223632., 227136.,
      217752., 221280., 224808., 228336., 218880., 222432., 225984., 229536.,
      220008., 223584., 227160., 230736., 221136., 224736., 228336., 231936.,
      235800., 239712., 243624., 247536., 236928., 240864., 244800., 248736.,
      238056., 242016., 245976., 249936., 239184., 243168., 247152., 251136.,
      240312., 244320., 248328., 252336., 241440., 245472., 249504., 253536.,
      242568., 246624., 250680., 254736., 243696., 247776., 251856., 255936.,
      244824., 248928., 253032., 257136., 245952., 250080., 254208., 258336.,
      247080., 251232., 255384., 259536., 248208., 252384., 256560., 260736.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43608., 58280., 43752., 55320., 73810.,
                                         55320., 43752., 58280., 43608.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5901., 6072., 6243., 6585., 6756.,
                                         6927., 7269., 7440., 7611.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86208.,  87216.,  115192., 116560., 86460.,  87504.,
      109290., 110640., 145790., 147620., 109245., 110640.,
      86352.,  87504.,  115000., 116560., 86028.,  87216.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11343., 11802., 11667., 12144., 11991., 12486., 12639., 13170., 12963.,
      13512., 13287., 13854., 13935., 14538., 14259., 14880., 14583., 15222.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171408., 172416., 173424., 174432., 229016., 230384., 231752., 233120.,
      171876., 172920., 173964., 175008., 217230., 218580., 219930., 221280.,
      289750., 291580., 293410., 295240., 217095., 218490., 219885., 221280.,
      171552., 172704., 173856., 175008., 228440., 230000., 231560., 233120.,
      170868., 172056., 173244., 174432.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22227., 22686., 23145., 23604., 22857., 23334., 23811., 24288., 23487.,
      23982., 24477., 24972., 24747., 25278., 25809., 26340., 25377., 25926.,
      26475., 27024., 26007., 26574., 27141., 27708., 27267., 27870., 28473.,
      29076., 27897., 28518., 29139., 29760., 28527., 29166., 29805., 30444.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86028.,  87216.,  115000., 116560., 86352.,  87504.,
      109245., 110640., 145790., 147620., 109290., 110640.,
      86460.,  87504.,  115192., 116560., 86208.,  87216.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11631., 11802., 11973., 12144., 12315., 12486., 12999., 13170., 13341.,
      13512., 13683., 13854., 14367., 14538., 14709., 14880., 15051., 15222.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170076., 172056., 172416., 174432., 227312., 230000., 230384., 233120.,
      170652., 172704., 172920., 175008., 215835., 218490., 218580., 221280.,
      287980., 291580., 291580., 295240., 215835., 218580., 218490., 221280.,
      170652., 172920., 172704., 175008., 227312., 230384., 230000., 233120.,
      170076., 172416., 172056., 174432.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22362., 23262., 22686., 23604., 23010., 23946., 23334., 24288., 23658.,
      24630., 23982., 24972., 24954., 25998., 25278., 26340., 25602., 26682.,
      25926., 27024., 26250., 27366., 26574., 27708., 27546., 28734., 27870.,
      29076., 28194., 29418., 28518., 29760., 28842., 30102., 29166., 30444.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      338172., 340152., 342132., 344112., 342816., 344832., 346848., 348864.,
      451936., 454624., 457312., 460000., 458032., 460768., 463504., 466240.,
      339252., 341304., 343356., 345408., 343752., 345840., 347928., 350016.,
      429015., 431670., 434325., 436980., 434460., 437160., 439860., 442560.,
      572360., 575960., 579560., 583160., 579500., 583160., 586820., 590480.,
      428925., 431670., 434415., 437160., 434190., 436980., 439770., 442560.,
      339036., 341304., 343572., 345840., 343104., 345408., 347712., 350016.,
      451552., 454624., 457696., 460768., 456880., 460000., 463120., 466240.,
      337812., 340152., 342492., 344832., 341736., 344112., 346488., 348864.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43824., 44724., 45624., 46524., 44454., 45372., 46290., 47208., 45084.,
      46020., 46956., 47892., 45714., 46668., 47622., 48576., 46344., 47316.,
      48288., 49260., 46974., 47964., 48954., 49944., 48864., 49908., 50952.,
      51996., 49494., 50556., 51618., 52680., 50124., 51204., 52284., 53364.,
      50754., 51852., 52950., 54048., 51384., 52500., 53616., 54732., 52014.,
      53148., 54282., 55416., 53904., 55092., 56280., 57468., 54534., 55740.,
      56946., 58152., 55164., 56388., 57612., 58836., 55794., 57036., 58278.,
      59520., 56424., 57684., 58944., 60204., 57054., 58332., 59610., 60888.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170868., 172056., 173244., 174432., 228440., 230000., 231560., 233120.,
      171552., 172704., 173856., 175008., 217095., 218490., 219885., 221280.,
      289750., 291580., 293410., 295240., 217230., 218580., 219930., 221280.,
      171876., 172920., 173964., 175008., 229016., 230384., 231752., 233120.,
      171408., 172416., 173424., 174432.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23091., 23262., 23433., 23604., 23775., 23946., 24117., 24288., 24459.,
      24630., 24801., 24972., 25827., 25998., 26169., 26340., 26511., 26682.,
      26853., 27024., 27195., 27366., 27537., 27708., 28563., 28734., 28905.,
      29076., 29247., 29418., 29589., 29760., 29931., 30102., 30273., 30444.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      337812., 341736., 340152., 344112., 342492., 346488., 344832., 348864.,
      451552., 456880., 454624., 460000., 457696., 463120., 460768., 466240.,
      339036., 343104., 341304., 345408., 343572., 347712., 345840., 350016.,
      428925., 434190., 431670., 436980., 434415., 439770., 437160., 442560.,
      572360., 579500., 575960., 583160., 579560., 586820., 583160., 590480.,
      429015., 434460., 431670., 437160., 434325., 439860., 436980., 442560.,
      339252., 343752., 341304., 345840., 343356., 347928., 345408., 350016.,
      451936., 458032., 454624., 460768., 457312., 463504., 460000., 466240.,
      338172., 342816., 340152., 344832., 342132., 346848., 344112., 348864.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44400., 46182., 44724., 46524., 45048., 46866., 45372., 47208., 45696.,
      47550., 46020., 47892., 46344., 48234., 46668., 48576., 46992., 48918.,
      47316., 49260., 47640., 49602., 47964., 49944., 49584., 51654., 49908.,
      51996., 50232., 52338., 50556., 52680., 50880., 53022., 51204., 53364.,
      51528., 53706., 51852., 54048., 52176., 54390., 52500., 54732., 52824.,
      55074., 53148., 55416., 54768., 57126., 55092., 57468., 55416., 57810.,
      55740., 58152., 56064., 58494., 56388., 58836., 56712., 59178., 57036.,
      59520., 57360., 59862., 57684., 60204., 58008., 60546., 58332., 60888.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      671700.,  675624.,  679548.,  683472.,  676344.,  680304.,  684264.,
      688224.,  680988.,  684984.,  688980.,  692976.,  685632.,  689664.,
      693696.,  697728.,  897776.,  903104.,  908432.,  913760.,  903872.,
      909248.,  914624.,  920000.,  909968.,  915392.,  920816.,  926240.,
      916064.,  921536.,  927008.,  932480.,  674004.,  678072.,  682140.,
      686208.,  678504.,  682608.,  686712.,  690816.,  683004.,  687144.,
      691284.,  695424.,  687504.,  691680.,  695856.,  700032.,  852585.,
      857850.,  863115.,  868380.,  858030.,  863340.,  868650.,  873960.,
      863475.,  868830.,  874185.,  879540.,  868920.,  874320.,  879720.,
      885120.,  1137580., 1144720., 1151860., 1159000., 1144720., 1151920.,
      1159120., 1166320., 1151860., 1159120., 1166380., 1173640., 1159000.,
      1166320., 1173640., 1180960., 852585.,  858030.,  863475.,  868920.,
      857850.,  863340.,  868830.,  874320.,  863115.,  868650.,  874185.,
      879720.,  868380.,  873960.,  879540.,  885120.,  674004.,  678504.,
      683004.,  687504.,  678072.,  682608.,  687144.,  691680.,  682140.,
      686712.,  691284.,  695856.,  686208.,  690816.,  695424.,  700032.,
      897776.,  903872.,  909968.,  916064.,  903104.,  909248.,  915392.,
      921536.,  908432.,  914624.,  920816.,  927008.,  913760.,  920000.,
      926240.,  932480.,  671700.,  676344.,  680988.,  685632.,  675624.,
      680304.,  684984.,  689664.,  679548.,  684264.,  688980.,  693696.,
      683472.,  688224.,  692976.,  697728.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87018.,  88800.,  90582.,  92364.,  87648.,  89448.,  91248.,  93048.,
      88278.,  90096.,  91914.,  93732.,  88908.,  90744.,  92580.,  94416.,
      89538.,  91392.,  93246.,  95100.,  90168.,  92040.,  93912.,  95784.,
      90798.,  92688.,  94578.,  96468.,  91428.,  93336.,  95244.,  97152.,
      92058.,  93984.,  95910.,  97836.,  92688.,  94632.,  96576.,  98520.,
      93318.,  95280.,  97242.,  99204.,  93948.,  95928.,  97908.,  99888.,
      97098.,  99168.,  101238., 103308., 97728.,  99816.,  101904., 103992.,
      98358.,  100464., 102570., 104676., 98988.,  101112., 103236., 105360.,
      99618.,  101760., 103902., 106044., 100248., 102408., 104568., 106728.,
      100878., 103056., 105234., 107412., 101508., 103704., 105900., 108096.,
      102138., 104352., 106566., 108780., 102768., 105000., 107232., 109464.,
      103398., 105648., 107898., 110148., 104028., 106296., 108564., 110832.,
      107178., 109536., 111894., 114252., 107808., 110184., 112560., 114936.,
      108438., 110832., 113226., 115620., 109068., 111480., 113892., 116304.,
      109698., 112128., 114558., 116988., 110328., 112776., 115224., 117672.,
      110958., 113424., 115890., 118356., 111588., 114072., 116556., 119040.,
      112218., 114720., 117222., 119724., 112848., 115368., 117888., 120408.,
      113478., 116016., 118554., 121092., 114108., 116664., 119220., 121776.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90440.,  113260., 90680.,
                                         114700., 143450., 114700.,
                                         90680.,  113260., 90440.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16434., 16812., 17190., 18324., 18702.,
                                         19080., 20214., 20592., 20970.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179200., 180880., 224390., 226520., 179632., 181360.,
      227150., 229400., 284050., 286900., 227090., 229400.,
      179440., 181360., 224090., 226520., 178912., 180880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32004., 32868., 32733., 33624., 33462., 34380., 35649., 36648., 36378.,
      37404., 37107., 38160., 39294., 40428., 40023., 41184., 40752., 41940.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      356720., 358400., 360080., 361760., 446650., 448780., 450910., 453040.,
      357536., 359264., 360992., 362720., 452050., 454300., 456550., 458800.,
      565250., 568100., 570950., 573800., 451870., 454180., 456490., 458800.,
      356960., 358880., 360800., 362720., 445750., 448180., 450610., 453040.,
      355856., 357824., 359792., 361760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63144., 64008., 64872., 65736., 64575., 65466., 66357., 67248., 66006.,
      66924., 67842., 68760., 70299., 71298., 72297., 73296., 71730., 72756.,
      73782., 74808., 73161., 74214., 75267., 76320., 77454., 78588., 79722.,
      80856., 78885., 80046., 81207., 82368., 80316., 81504., 82692., 83880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      178912., 180880., 224090., 226520., 179440., 181360.,
      227090., 229400., 284050., 286900., 227150., 229400.,
      179632., 181360., 224390., 226520., 179200., 180880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32490., 32868., 33246., 33624., 34002., 34380., 36270., 36648., 37026.,
      37404., 37782., 38160., 40050., 40428., 40806., 41184., 41562., 41940.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      354512., 357824., 358400., 361760., 443980., 448180., 448780., 453040.,
      355472., 358880., 359264., 362720., 449740., 454180., 454300., 458800.,
      562475., 568100., 568100., 573800., 449740., 454300., 454180., 458800.,
      355472., 359264., 358880., 362720., 443980., 448780., 448180., 453040.,
      354512., 358400., 357824., 361760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63279., 64980., 64008., 65736., 64737., 66492., 65466., 67248., 66195.,
      68004., 66924., 68760., 70569., 72540., 71298., 73296., 72027., 74052.,
      72756., 74808., 73485., 75564., 74214., 76320., 77859., 80100., 78588.,
      80856., 79317., 81612., 80046., 82368., 80775., 83124., 81504., 83880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705712.,  709024.,  712336.,  715648.,  713440.,  716800.,  720160.,
      723520.,  883760.,  887960.,  892160.,  896360.,  893300.,  897560.,
      901820.,  906080.,  707536.,  710944.,  714352.,  717760.,  715072.,
      718528.,  721984.,  725440.,  895040.,  899480.,  903920.,  908360.,
      904100.,  908600.,  913100.,  917600.,  1119325., 1124950., 1130575.,
      1136200., 1130500., 1136200., 1141900., 1147600., 894920.,  899480.,
      904040.,  908600.,  903740.,  908360.,  912980.,  917600.,  707152.,
      710944.,  714736.,  718528.,  713920.,  717760.,  721600.,  725440.,
      883160.,  887960.,  892760.,  897560.,  891500.,  896360.,  901220.,
      906080.,  705136.,  709024.,  712912.,  716800.,  711712.,  715648.,
      719584.,  723520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      124857., 126558., 128259., 129960., 126288., 128016., 129744., 131472.,
      127719., 129474., 131229., 132984., 129150., 130932., 132714., 134496.,
      130581., 132390., 134199., 136008., 132012., 133848., 135684., 137520.,
      139167., 141138., 143109., 145080., 140598., 142596., 144594., 146592.,
      142029., 144054., 146079., 148104., 143460., 145512., 147564., 149616.,
      144891., 146970., 149049., 151128., 146322., 148428., 150534., 152640.,
      153477., 155718., 157959., 160200., 154908., 157176., 159444., 161712.,
      156339., 158634., 160929., 163224., 157770., 160092., 162414., 164736.,
      159201., 161550., 163899., 166248., 160632., 163008., 165384., 167760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      355856., 357824., 359792., 361760., 445750., 448180., 450610., 453040.,
      356960., 358880., 360800., 362720., 451870., 454180., 456490., 458800.,
      565250., 568100., 570950., 573800., 452050., 454300., 456550., 458800.,
      357536., 359264., 360992., 362720., 446650., 448780., 450910., 453040.,
      356720., 358400., 360080., 361760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      64602., 64980., 65358., 65736., 66114., 66492., 66870., 67248., 67626.,
      68004., 68382., 68760., 72162., 72540., 72918., 73296., 73674., 74052.,
      74430., 74808., 75186., 75564., 75942., 76320., 79722., 80100., 80478.,
      80856., 81234., 81612., 81990., 82368., 82746., 83124., 83502., 83880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705136.,  711712.,  709024.,  715648.,  712912.,  719584.,  716800.,
      723520.,  883160.,  891500.,  887960.,  896360.,  892760.,  901220.,
      897560.,  906080.,  707152.,  713920.,  710944.,  717760.,  714736.,
      721600.,  718528.,  725440.,  894920.,  903740.,  899480.,  908360.,
      904040.,  912980.,  908600.,  917600.,  1119325., 1130500., 1124950.,
      1136200., 1130575., 1141900., 1136200., 1147600., 895040.,  904100.,
      899480.,  908600.,  903920.,  913100.,  908360.,  917600.,  707536.,
      715072.,  710944.,  718528.,  714352.,  721984.,  717760.,  725440.,
      883760.,  893300.,  887960.,  897560.,  892160.,  901820.,  896360.,
      906080.,  705712.,  713440.,  709024.,  716800.,  712336.,  720160.,
      715648.,  723520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125829., 129204., 126558., 129960., 127287., 130716., 128016., 131472.,
      128745., 132228., 129474., 132984., 130203., 133740., 130932., 134496.,
      131661., 135252., 132390., 136008., 133119., 136764., 133848., 137520.,
      140409., 144324., 141138., 145080., 141867., 145836., 142596., 146592.,
      143325., 147348., 144054., 148104., 144783., 148860., 145512., 149616.,
      146241., 150372., 146970., 151128., 147699., 151884., 148428., 152640.,
      154989., 159444., 155718., 160200., 156447., 160956., 157176., 161712.,
      157905., 162468., 158634., 163224., 159363., 163980., 160092., 164736.,
      160821., 165492., 161550., 166248., 162279., 167004., 163008., 167760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1403696., 1410272., 1416848., 1423424., 1411424., 1418048., 1424672.,
      1431296., 1419152., 1425824., 1432496., 1439168., 1426880., 1433600.,
      1440320., 1447040., 1757980., 1766320., 1774660., 1783000., 1767520.,
      1775920., 1784320., 1792720., 1777060., 1785520., 1793980., 1802440.,
      1786600., 1795120., 1803640., 1812160., 1407536., 1414304., 1421072.,
      1427840., 1415072., 1421888., 1428704., 1435520., 1422608., 1429472.,
      1436336., 1443200., 1430144., 1437056., 1443968., 1450880., 1781020.,
      1789840., 1798660., 1807480., 1790080., 1798960., 1807840., 1816720.,
      1799140., 1808080., 1817020., 1825960., 1808200., 1817200., 1826200.,
      1835200., 2227475., 2238650., 2249825., 2261000., 2238650., 2249900.,
      2261150., 2272400., 2249825., 2261150., 2272475., 2283800., 2261000.,
      2272400., 2283800., 2295200., 1781020., 1790080., 1799140., 1808200.,
      1789840., 1798960., 1808080., 1817200., 1798660., 1807840., 1817020.,
      1826200., 1807480., 1816720., 1825960., 1835200., 1407536., 1415072.,
      1422608., 1430144., 1414304., 1421888., 1429472., 1437056., 1421072.,
      1428704., 1436336., 1443968., 1427840., 1435520., 1443200., 1450880.,
      1757980., 1767520., 1777060., 1786600., 1766320., 1775920., 1785520.,
      1795120., 1774660., 1784320., 1793980., 1803640., 1783000., 1792720.,
      1802440., 1812160., 1403696., 1411424., 1419152., 1426880., 1410272.,
      1418048., 1425824., 1433600., 1416848., 1424672., 1432496., 1440320.,
      1423424., 1431296., 1439168., 1447040.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248283., 251658., 255033., 258408., 249714., 253116., 256518., 259920.,
      251145., 254574., 258003., 261432., 252576., 256032., 259488., 262944.,
      254007., 257490., 260973., 264456., 255438., 258948., 262458., 265968.,
      256869., 260406., 263943., 267480., 258300., 261864., 265428., 268992.,
      259731., 263322., 266913., 270504., 261162., 264780., 268398., 272016.,
      262593., 266238., 269883., 273528., 264024., 267696., 271368., 275040.,
      276903., 280818., 284733., 288648., 278334., 282276., 286218., 290160.,
      279765., 283734., 287703., 291672., 281196., 285192., 289188., 293184.,
      282627., 286650., 290673., 294696., 284058., 288108., 292158., 296208.,
      285489., 289566., 293643., 297720., 286920., 291024., 295128., 299232.,
      288351., 292482., 296613., 300744., 289782., 293940., 298098., 302256.,
      291213., 295398., 299583., 303768., 292644., 296856., 301068., 305280.,
      305523., 309978., 314433., 318888., 306954., 311436., 315918., 320400.,
      308385., 312894., 317403., 321912., 309816., 314352., 318888., 323424.,
      311247., 315810., 320373., 324936., 312678., 317268., 321858., 326448.,
      314109., 318726., 323343., 327960., 315540., 320184., 324828., 329472.,
      316971., 321642., 326313., 330984., 318402., 323100., 327798., 332496.,
      319833., 324558., 329283., 334008., 321264., 326016., 330768., 335520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {162300., 195060., 162660.,
                                         205800., 247065., 205800.,
                                         162660., 195060., 162300.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34902., 35568., 36234., 38898., 39564.,
                                         40230., 42894., 43560., 44226.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322080., 324600., 387060., 390120., 322740., 325320.,
      408225., 411600., 490035., 494130., 408150., 411600.,
      322440., 325320., 386628., 390120., 321660., 324600.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68418., 69804., 69714., 71136., 71010., 72468., 76194., 77796., 77490.,
      79128., 78786., 80460., 83970., 85788., 85266., 87120., 86562., 88452.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      641640., 644160., 646680., 649200., 771060., 774120., 777180., 780240.,
      642900., 645480., 648060., 650640., 813075., 816450., 819825., 823200.,
      975975., 980070., 984165., 988260., 812850., 816300., 819750., 823200.,
      642000., 644880., 647760., 650640., 769764., 773256., 776748., 780240.,
      640380., 643320., 646260., 649200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135450., 136836., 138222., 139608., 138006., 139428., 140850., 142272.,
      140562., 142020., 143478., 144936., 150786., 152388., 153990., 155592.,
      153342., 154980., 156618., 158256., 155898., 157572., 159246., 160920.,
      166122., 167940., 169758., 171576., 168678., 170532., 172386., 174240.,
      171234., 173124., 175014., 176904.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321660., 324600., 386628., 390120., 322440., 325320.,
      408150., 411600., 490035., 494130., 408225., 411600.,
      322740., 325320., 387060., 390120., 322080., 324600.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69138., 69804., 70470., 71136., 71802., 72468., 77130., 77796., 78462.,
      79128., 79794., 80460., 85122., 85788., 86454., 87120., 87786., 88452.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      638340., 643320., 644160., 649200., 767208., 773256., 774120., 780240.,
      639780., 644880., 645480., 650640., 809625., 816300., 816450., 823200.,
      971970., 980070., 980070., 988260., 809625., 816450., 816300., 823200.,
      639780., 645480., 644880., 650640., 767208., 774120., 773256., 780240.,
      638340., 644160., 643320., 649200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135540., 138276., 136836., 139608., 138132., 140940., 139428., 142272.,
      140724., 143604., 142020., 144936., 151092., 154260., 152388., 155592.,
      153684., 156924., 154980., 158256., 156276., 159588., 157572., 160920.,
      166644., 170244., 167940., 171576., 169236., 172908., 170532., 174240.,
      171828., 175572., 173124., 176904.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1271700., 1276680., 1281660., 1286640., 1283280., 1288320., 1293360.,
      1298400., 1528368., 1534416., 1540464., 1546512., 1542120., 1548240.,
      1554360., 1560480., 1274460., 1279560., 1284660., 1289760., 1285800.,
      1290960., 1296120., 1301280., 1612575., 1619250., 1625925., 1632600.,
      1626150., 1632900., 1639650., 1646400., 1935840., 1943940., 1952040.,
      1960140., 1951950., 1960140., 1968330., 1976520., 1612425., 1619250.,
      1626075., 1632900., 1625700., 1632600., 1639500., 1646400., 1273860.,
      1279560., 1285260., 1290960., 1284000., 1289760., 1295520., 1301280.,
      1527504., 1534416., 1541328., 1548240., 1539528., 1546512., 1553496.,
      1560480., 1270860., 1276680., 1282500., 1288320., 1280760., 1286640.,
      1292520., 1298400.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      268344., 271080., 273816., 276552., 270900., 273672., 276444., 279216.,
      273456., 276264., 279072., 281880., 276012., 278856., 281700., 284544.,
      278568., 281448., 284328., 287208., 281124., 284040., 286956., 289872.,
      299016., 302184., 305352., 308520., 301572., 304776., 307980., 311184.,
      304128., 307368., 310608., 313848., 306684., 309960., 313236., 316512.,
      309240., 312552., 315864., 319176., 311796., 315144., 318492., 321840.,
      329688., 333288., 336888., 340488., 332244., 335880., 339516., 343152.,
      334800., 338472., 342144., 345816., 337356., 341064., 344772., 348480.,
      339912., 343656., 347400., 351144., 342468., 346248., 350028., 353808.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      640380., 643320., 646260., 649200., 769764., 773256., 776748., 780240.,
      642000., 644880., 647760., 650640., 812850., 816300., 819750., 823200.,
      975975., 980070., 984165., 988260., 813075., 816450., 819825., 823200.,
      642900., 645480., 648060., 650640., 771060., 774120., 777180., 780240.,
      641640., 644160., 646680., 649200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      137610., 138276., 138942., 139608., 140274., 140940., 141606., 142272.,
      142938., 143604., 144270., 144936., 153594., 154260., 154926., 155592.,
      156258., 156924., 157590., 158256., 158922., 159588., 160254., 160920.,
      169578., 170244., 170910., 171576., 172242., 172908., 173574., 174240.,
      174906., 175572., 176238., 176904.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1270860., 1280760., 1276680., 1286640., 1282500., 1292520., 1288320.,
      1298400., 1527504., 1539528., 1534416., 1546512., 1541328., 1553496.,
      1548240., 1560480., 1273860., 1284000., 1279560., 1289760., 1285260.,
      1295520., 1290960., 1301280., 1612425., 1625700., 1619250., 1632600.,
      1626075., 1639500., 1632900., 1646400., 1935840., 1951950., 1943940.,
      1960140., 1952040., 1968330., 1960140., 1976520., 1612575., 1626150.,
      1619250., 1632900., 1625925., 1639650., 1632600., 1646400., 1274460.,
      1285800., 1279560., 1290960., 1284660., 1296120., 1289760., 1301280.,
      1528368., 1542120., 1534416., 1548240., 1540464., 1554360., 1546512.,
      1560480., 1271700., 1283280., 1276680., 1288320., 1281660., 1293360.,
      1286640., 1298400.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      269784., 275220., 271080., 276552., 272376., 277884., 273672., 279216.,
      274968., 280548., 276264., 281880., 277560., 283212., 278856., 284544.,
      280152., 285876., 281448., 287208., 282744., 288540., 284040., 289872.,
      300888., 307188., 302184., 308520., 303480., 309852., 304776., 311184.,
      306072., 312516., 307368., 313848., 308664., 315180., 309960., 316512.,
      311256., 317844., 312552., 319176., 313848., 320508., 315144., 321840.,
      331992., 339156., 333288., 340488., 334584., 341820., 335880., 343152.,
      337176., 344484., 338472., 345816., 339768., 347148., 341064., 348480.,
      342360., 349812., 343656., 351144., 344952., 352476., 346248., 353808.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2531820., 2541720., 2551620., 2561520., 2543400., 2553360., 2563320.,
      2573280., 2554980., 2565000., 2575020., 2585040., 2566560., 2576640.,
      2586720., 2596800., 3042984., 3055008., 3067032., 3079056., 3056736.,
      3068832., 3080928., 3093024., 3070488., 3082656., 3094824., 3106992.,
      3084240., 3096480., 3108720., 3120960., 2537580., 2547720., 2557860.,
      2568000., 2548920., 2559120., 2569320., 2579520., 2560260., 2570520.,
      2580780., 2591040., 2571600., 2581920., 2592240., 2602560., 3211575.,
      3224850., 3238125., 3251400., 3225150., 3238500., 3251850., 3265200.,
      3238725., 3252150., 3265575., 3279000., 3252300., 3265800., 3279300.,
      3292800., 3855570., 3871680., 3887790., 3903900., 3871680., 3887880.,
      3904080., 3920280., 3887790., 3904080., 3920370., 3936660., 3903900.,
      3920280., 3936660., 3953040., 3211575., 3225150., 3238725., 3252300.,
      3224850., 3238500., 3252150., 3265800., 3238125., 3251850., 3265575.,
      3279300., 3251400., 3265200., 3279000., 3292800., 2537580., 2548920.,
      2560260., 2571600., 2547720., 2559120., 2570520., 2581920., 2557860.,
      2569320., 2580780., 2592240., 2568000., 2579520., 2591040., 2602560.,
      3042984., 3056736., 3070488., 3084240., 3055008., 3068832., 3082656.,
      3096480., 3067032., 3080928., 3094824., 3108720., 3079056., 3093024.,
      3106992., 3120960., 2531820., 2543400., 2554980., 2566560., 2541720.,
      2553360., 2565000., 2576640., 2551620., 2563320., 2575020., 2586720.,
      2561520., 2573280., 2585040., 2596800.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      534132., 539568., 545004., 550440., 536688., 542160., 547632., 553104.,
      539244., 544752., 550260., 555768., 541800., 547344., 552888., 558432.,
      544356., 549936., 555516., 561096., 546912., 552528., 558144., 563760.,
      549468., 555120., 560772., 566424., 552024., 557712., 563400., 569088.,
      554580., 560304., 566028., 571752., 557136., 562896., 568656., 574416.,
      559692., 565488., 571284., 577080., 562248., 568080., 573912., 579744.,
      595476., 601776., 608076., 614376., 598032., 604368., 610704., 617040.,
      600588., 606960., 613332., 619704., 603144., 609552., 615960., 622368.,
      605700., 612144., 618588., 625032., 608256., 614736., 621216., 627696.,
      610812., 617328., 623844., 630360., 613368., 619920., 626472., 633024.,
      615924., 622512., 629100., 635688., 618480., 625104., 631728., 638352.,
      621036., 627696., 634356., 641016., 623592., 630288., 636984., 643680.,
      656820., 663984., 671148., 678312., 659376., 666576., 673776., 680976.,
      661932., 669168., 676404., 683640., 664488., 671760., 679032., 686304.,
      667044., 674352., 681660., 688968., 669600., 676944., 684288., 691632.,
      672156., 679536., 686916., 694296., 674712., 682128., 689544., 696960.,
      677268., 684720., 692172., 699624., 679824., 687312., 694800., 702288.,
      682380., 689904., 697428., 704952., 684936., 692496., 700056., 707616.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78420., 104730., 78600.,
                                         95220., 127020., 95220.,
                                         78600., 104730., 78420.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12768., 13068., 13368., 13968., 14268.,
                                         14568., 15168., 15468., 15768.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      155310., 156840., 207390., 209460., 155625., 157200.,
      188496., 190440., 251412., 254040., 188442., 190440.,
      155490., 157200., 207150., 209460., 155085., 156840.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24780., 25536., 25356., 26136., 25932., 26736., 27084., 27936., 27660.,
      28536., 28236., 29136., 29388., 30336., 29964., 30936., 30540., 31536.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      309090., 310620., 312150., 313680., 412710., 414780., 416850., 418920.,
      309675., 311250., 312825., 314400., 375048., 376992., 378936., 380880.,
      500196., 502824., 505452., 508080., 374886., 376884., 378882., 380880.,
      309270., 310980., 312690., 314400., 411990., 414300., 416610., 418920.,
      308415., 310170., 311925., 313680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48804., 49560., 50316., 51072., 49932., 50712., 51492., 52272., 51060.,
      51864., 52668., 53472., 53316., 54168., 55020., 55872., 54444., 55320.,
      56196., 57072., 55572., 56472., 57372., 58272., 57828., 58776., 59724.,
      60672., 58956., 59928., 60900., 61872., 60084., 61080., 62076., 63072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      155085., 156840., 207150., 209460., 155490., 157200.,
      188442., 190440., 251412., 254040., 188496., 190440.,
      155625., 157200., 207390., 209460., 155310., 156840.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25236., 25536., 25836., 26136., 26436., 26736., 27636., 27936., 28236.,
      28536., 28836., 29136., 30036., 30336., 30636., 30936., 31236., 31536.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      307155., 310170., 310620., 313680., 410220., 414300., 414780., 418920.,
      307875., 310980., 311250., 314400., 373050., 376884., 376992., 380880.,
      497640., 502824., 502824., 508080., 373050., 376992., 376884., 380880.,
      307875., 311250., 310980., 314400., 410220., 414780., 414300., 418920.,
      307155., 310620., 310170., 313680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48984., 50472., 49560., 51072., 50136., 51672., 50712., 52272., 51288.,
      52872., 51864., 53472., 53592., 55272., 54168., 55872., 54744., 56472.,
      55320., 57072., 55896., 57672., 56472., 58272., 58200., 60072., 58776.,
      60672., 59352., 61272., 59928., 61872., 60504., 62472., 61080., 63072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      611295.,  614310.,  617325.,  620340.,  618180.,  621240., 624300.,
      627360.,  816360.,  820440.,  824520.,  828600.,  825420., 829560.,
      833700.,  837840.,  612645.,  615750.,  618855.,  621960., 619350.,
      622500.,  625650.,  628800.,  742266.,  746100.,  749934., 753768.,
      750096.,  753984.,  757872.,  761760.,  990096.,  995280., 1000464.,
      1005648., 1000392., 1005648., 1010904., 1016160., 742158., 746100.,
      750042.,  753984.,  749772.,  753768.,  757764.,  761760., 612375.,
      615750.,  619125.,  622500.,  618540.,  621960.,  625380., 628800.,
      815880.,  820440.,  825000.,  829560.,  823980.,  828600., 833220.,
      837840.,  610845.,  614310.,  617775.,  621240.,  616830., 620340.,
      623850.,  627360.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96480.,  97968.,  99456.,  100944., 97608.,  99120.,  100632., 102144.,
      98736.,  100272., 101808., 103344., 99864.,  101424., 102984., 104544.,
      100992., 102576., 104160., 105744., 102120., 103728., 105336., 106944.,
      105504., 107184., 108864., 110544., 106632., 108336., 110040., 111744.,
      107760., 109488., 111216., 112944., 108888., 110640., 112392., 114144.,
      110016., 111792., 113568., 115344., 111144., 112944., 114744., 116544.,
      114528., 116400., 118272., 120144., 115656., 117552., 119448., 121344.,
      116784., 118704., 120624., 122544., 117912., 119856., 121800., 123744.,
      119040., 121008., 122976., 124944., 120168., 122160., 124152., 126144.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      308415., 310170., 311925., 313680., 411990., 414300., 416610., 418920.,
      309270., 310980., 312690., 314400., 374886., 376884., 378882., 380880.,
      500196., 502824., 505452., 508080., 375048., 376992., 378936., 380880.,
      309675., 311250., 312825., 314400., 412710., 414780., 416850., 418920.,
      309090., 310620., 312150., 313680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50172., 50472., 50772., 51072., 51372., 51672., 51972., 52272., 52572.,
      52872., 53172., 53472., 54972., 55272., 55572., 55872., 56172., 56472.,
      56772., 57072., 57372., 57672., 57972., 58272., 59772., 60072., 60372.,
      60672., 60972., 61272., 61572., 61872., 62172., 62472., 62772., 63072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      610845.,  616830.,  614310.,  620340.,  617775.,  623850.,  621240.,
      627360.,  815880.,  823980.,  820440.,  828600.,  825000.,  833220.,
      829560.,  837840.,  612375.,  618540.,  615750.,  621960.,  619125.,
      625380.,  622500.,  628800.,  742158.,  749772.,  746100.,  753768.,
      750042.,  757764.,  753984.,  761760.,  990096.,  1000392., 995280.,
      1005648., 1000464., 1010904., 1005648., 1016160., 742266.,  750096.,
      746100.,  753984.,  749934.,  757872.,  753768.,  761760.,  612645.,
      619350.,  615750.,  622500.,  618855.,  625650.,  621960.,  628800.,
      816360.,  825420.,  820440.,  829560.,  824520.,  833700.,  828600.,
      837840.,  611295.,  618180.,  614310.,  621240.,  617325.,  624300.,
      620340.,  627360.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97392.,  100344., 97968.,  100944., 98544.,  101544., 99120.,  102144.,
      99696.,  102744., 100272., 103344., 100848., 103944., 101424., 104544.,
      102000., 105144., 102576., 105744., 103152., 106344., 103728., 106944.,
      106608., 109944., 107184., 110544., 107760., 111144., 108336., 111744.,
      108912., 112344., 109488., 112944., 110064., 113544., 110640., 114144.,
      111216., 114744., 111792., 115344., 112368., 115944., 112944., 116544.,
      115824., 119544., 116400., 120144., 116976., 120744., 117552., 121344.,
      118128., 121944., 118704., 122544., 119280., 123144., 119856., 123744.,
      120432., 124344., 121008., 124944., 121584., 125544., 122160., 126144.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1215705., 1221690., 1227675., 1233660., 1222590., 1228620., 1234650.,
      1240680., 1229475., 1235550., 1241625., 1247700., 1236360., 1242480.,
      1248600., 1254720., 1623660., 1631760., 1639860., 1647960., 1632720.,
      1640880., 1649040., 1657200., 1641780., 1650000., 1658220., 1666440.,
      1650840., 1659120., 1667400., 1675680., 1218585., 1224750., 1230915.,
      1237080., 1225290., 1231500., 1237710., 1243920., 1231995., 1238250.,
      1244505., 1250760., 1238700., 1245000., 1251300., 1257600., 1476702.,
      1484316., 1491930., 1499544., 1484532., 1492200., 1499868., 1507536.,
      1492362., 1500084., 1507806., 1515528., 1500192., 1507968., 1515744.,
      1523520., 1969896., 1980192., 1990488., 2000784., 1980192., 1990560.,
      2000928., 2011296., 1990488., 2000928., 2011368., 2021808., 2000784.,
      2011296., 2021808., 2032320., 1476702., 1484532., 1492362., 1500192.,
      1484316., 1492200., 1500084., 1507968., 1491930., 1499868., 1507806.,
      1515744., 1499544., 1507536., 1515528., 1523520., 1218585., 1225290.,
      1231995., 1238700., 1224750., 1231500., 1238250., 1245000., 1230915.,
      1237710., 1244505., 1251300., 1237080., 1243920., 1250760., 1257600.,
      1623660., 1632720., 1641780., 1650840., 1631760., 1640880., 1650000.,
      1659120., 1639860., 1649040., 1658220., 1667400., 1647960., 1657200.,
      1666440., 1675680., 1215705., 1222590., 1229475., 1236360., 1221690.,
      1228620., 1235550., 1242480., 1227675., 1234650., 1241625., 1248600.,
      1233660., 1240680., 1247700., 1254720.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191832., 194784., 197736., 200688., 192960., 195936., 198912., 201888.,
      194088., 197088., 200088., 203088., 195216., 198240., 201264., 204288.,
      196344., 199392., 202440., 205488., 197472., 200544., 203616., 206688.,
      198600., 201696., 204792., 207888., 199728., 202848., 205968., 209088.,
      200856., 204000., 207144., 210288., 201984., 205152., 208320., 211488.,
      203112., 206304., 209496., 212688., 204240., 207456., 210672., 213888.,
      209880., 213216., 216552., 219888., 211008., 214368., 217728., 221088.,
      212136., 215520., 218904., 222288., 213264., 216672., 220080., 223488.,
      214392., 217824., 221256., 224688., 215520., 218976., 222432., 225888.,
      216648., 220128., 223608., 227088., 217776., 221280., 224784., 228288.,
      218904., 222432., 225960., 229488., 220032., 223584., 227136., 230688.,
      221160., 224736., 228312., 231888., 222288., 225888., 229488., 233088.,
      227928., 231648., 235368., 239088., 229056., 232800., 236544., 240288.,
      230184., 233952., 237720., 241488., 231312., 235104., 238896., 242688.,
      232440., 236256., 240072., 243888., 233568., 237408., 241248., 245088.,
      234696., 238560., 242424., 246288., 235824., 239712., 243600., 247488.,
      236952., 240864., 244776., 248688., 238080., 242016., 245952., 249888.,
      239208., 243168., 247128., 251088., 240336., 244320., 248304., 252288.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {162750., 203700., 163050.,
                                         197580., 247065., 197580.,
                                         163050., 203700., 162750.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35646., 36312., 36978., 38976., 39642.,
                                         40308., 42306., 42972., 43638.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322950., 325500., 404175., 407400., 323490., 326100.,
      391920., 395160., 490035., 494130., 391848., 395160.,
      323250., 326100., 403800., 407400., 322590., 325500.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69870., 71292., 71166., 72624., 72462., 73956., 76350., 77952., 77646.,
      79284., 78942., 80616., 82830., 84612., 84126., 85944., 85422., 87276.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643350., 645900., 648450., 651000., 805125., 808350., 811575., 814800.,
      644370., 646980., 649590., 652200., 780600., 783840., 787080., 790320.,
      975975., 980070., 984165., 988260., 780384., 783696., 787008., 790320.,
      643650., 646500., 649350., 652200., 804000., 807600., 811200., 814800.,
      642270., 645180., 648090., 651000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138318., 139740., 141162., 142584., 140874., 142332., 143790., 145248.,
      143430., 144924., 146418., 147912., 151098., 152700., 154302., 155904.,
      153654., 155292., 156930., 158568., 156210., 157884., 159558., 161232.,
      163878., 165660., 167442., 169224., 166434., 168252., 170070., 171888.,
      168990., 170844., 172698., 174552.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322590., 325500., 403800., 407400., 323250., 326100.,
      391848., 395160., 490035., 494130., 391920., 395160.,
      323490., 326100., 404175., 407400., 322950., 325500.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      70626., 71292., 71958., 72624., 73290., 73956., 77286., 77952., 78618.,
      79284., 79950., 80616., 83946., 84612., 85278., 85944., 86610., 87276.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      640140., 645180., 645900., 651000., 801225., 807600., 808350., 814800.,
      641340., 646500., 646980., 652200., 777288., 783696., 783840., 790320.,
      971970., 980070., 980070., 988260., 777288., 783840., 783696., 790320.,
      641340., 646980., 646500., 652200., 801225., 808350., 807600., 814800.,
      640140., 645900., 645180., 651000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138444., 141252., 139740., 142584., 141036., 143916., 142332., 145248.,
      143628., 146580., 144924., 147912., 151404., 154572., 152700., 155904.,
      153996., 157236., 155292., 158568., 156588., 159900., 157884., 161232.,
      164364., 167892., 165660., 169224., 166956., 170556., 168252., 171888.,
      169548., 173220., 170844., 174552.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1275240., 1280280., 1285320., 1290360., 1286700., 1291800., 1296900.,
      1302000., 1596075., 1602450., 1608825., 1615200., 1610250., 1616700.,
      1623150., 1629600., 1277520., 1282680., 1287840., 1293000., 1288740.,
      1293960., 1299180., 1304400., 1548168., 1554576., 1560984., 1567392.,
      1561200., 1567680., 1574160., 1580640., 1935840., 1943940., 1952040.,
      1960140., 1951950., 1960140., 1968330., 1976520., 1548024., 1554576.,
      1561128., 1567680., 1560768., 1567392., 1574016., 1580640., 1277040.,
      1282680., 1288320., 1293960., 1287300., 1293000., 1298700., 1304400.,
      1595325., 1602450., 1609575., 1616700., 1608000., 1615200., 1622400.,
      1629600., 1274520., 1280280., 1286040., 1291800., 1284540., 1290360.,
      1296180., 1302000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      274080., 276888., 279696., 282504., 276636., 279480., 282324., 285168.,
      279192., 282072., 284952., 287832., 281748., 284664., 287580., 290496.,
      284304., 287256., 290208., 293160., 286860., 289848., 292836., 295824.,
      299640., 302808., 305976., 309144., 302196., 305400., 308604., 311808.,
      304752., 307992., 311232., 314472., 307308., 310584., 313860., 317136.,
      309864., 313176., 316488., 319800., 312420., 315768., 319116., 322464.,
      325200., 328728., 332256., 335784., 327756., 331320., 334884., 338448.,
      330312., 333912., 337512., 341112., 332868., 336504., 340140., 343776.,
      335424., 339096., 342768., 346440., 337980., 341688., 345396., 349104.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      642270., 645180., 648090., 651000., 804000., 807600., 811200., 814800.,
      643650., 646500., 649350., 652200., 780384., 783696., 787008., 790320.,
      975975., 980070., 984165., 988260., 780600., 783840., 787080., 790320.,
      644370., 646980., 649590., 652200., 805125., 808350., 811575., 814800.,
      643350., 645900., 648450., 651000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      140586., 141252., 141918., 142584., 143250., 143916., 144582., 145248.,
      145914., 146580., 147246., 147912., 153906., 154572., 155238., 155904.,
      156570., 157236., 157902., 158568., 159234., 159900., 160566., 161232.,
      167226., 167892., 168558., 169224., 169890., 170556., 171222., 171888.,
      172554., 173220., 173886., 174552.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1274520., 1284540., 1280280., 1290360., 1286040., 1296180., 1291800.,
      1302000., 1595325., 1608000., 1602450., 1615200., 1609575., 1622400.,
      1616700., 1629600., 1277040., 1287300., 1282680., 1293000., 1288320.,
      1298700., 1293960., 1304400., 1548024., 1560768., 1554576., 1567392.,
      1561128., 1574016., 1567680., 1580640., 1935840., 1951950., 1943940.,
      1960140., 1952040., 1968330., 1960140., 1976520., 1548168., 1561200.,
      1554576., 1567680., 1560984., 1574160., 1567392., 1580640., 1277520.,
      1288740., 1282680., 1293960., 1287840., 1299180., 1293000., 1304400.,
      1596075., 1610250., 1602450., 1616700., 1608825., 1623150., 1615200.,
      1629600., 1275240., 1286700., 1280280., 1291800., 1285320., 1296900.,
      1290360., 1302000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      275592., 281172., 276888., 282504., 278184., 283836., 279480., 285168.,
      280776., 286500., 282072., 287832., 283368., 289164., 284664., 290496.,
      285960., 291828., 287256., 293160., 288552., 294492., 289848., 295824.,
      301512., 307812., 302808., 309144., 304104., 310476., 305400., 311808.,
      306696., 313140., 307992., 314472., 309288., 315804., 310584., 317136.,
      311880., 318468., 313176., 319800., 314472., 321132., 315768., 322464.,
      327432., 334452., 328728., 335784., 330024., 337116., 331320., 338448.,
      332616., 339780., 333912., 341112., 335208., 342444., 336504., 343776.,
      337800., 345108., 339096., 346440., 340392., 347772., 341688., 349104.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2539020., 2549040., 2559060., 2569080., 2550480., 2560560., 2570640.,
      2580720., 2561940., 2572080., 2582220., 2592360., 2573400., 2583600.,
      2593800., 2604000., 3177975., 3190650., 3203325., 3216000., 3192150.,
      3204900., 3217650., 3230400., 3206325., 3219150., 3231975., 3244800.,
      3220500., 3233400., 3246300., 3259200., 2543820., 2554080., 2564340.,
      2574600., 2555040., 2565360., 2575680., 2586000., 2566260., 2576640.,
      2587020., 2597400., 2577480., 2587920., 2598360., 2608800., 3083304.,
      3096048., 3108792., 3121536., 3096336., 3109152., 3121968., 3134784.,
      3109368., 3122256., 3135144., 3148032., 3122400., 3135360., 3148320.,
      3161280., 3855570., 3871680., 3887790., 3903900., 3871680., 3887880.,
      3904080., 3920280., 3887790., 3904080., 3920370., 3936660., 3903900.,
      3920280., 3936660., 3953040., 3083304., 3096336., 3109368., 3122400.,
      3096048., 3109152., 3122256., 3135360., 3108792., 3121968., 3135144.,
      3148320., 3121536., 3134784., 3148032., 3161280., 2543820., 2555040.,
      2566260., 2577480., 2554080., 2565360., 2576640., 2587920., 2564340.,
      2575680., 2587020., 2598360., 2574600., 2586000., 2597400., 2608800.,
      3177975., 3192150., 3206325., 3220500., 3190650., 3204900., 3219150.,
      3233400., 3203325., 3217650., 3231975., 3246300., 3216000., 3230400.,
      3244800., 3259200., 2539020., 2550480., 2561940., 2573400., 2549040.,
      2560560., 2572080., 2583600., 2559060., 2570640., 2582220., 2593800.,
      2569080., 2580720., 2592360., 2604000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      545604., 551184., 556764., 562344., 548160., 553776., 559392., 565008.,
      550716., 556368., 562020., 567672., 553272., 558960., 564648., 570336.,
      555828., 561552., 567276., 573000., 558384., 564144., 569904., 575664.,
      560940., 566736., 572532., 578328., 563496., 569328., 575160., 580992.,
      566052., 571920., 577788., 583656., 568608., 574512., 580416., 586320.,
      571164., 577104., 583044., 588984., 573720., 579696., 585672., 591648.,
      596724., 603024., 609324., 615624., 599280., 605616., 611952., 618288.,
      601836., 608208., 614580., 620952., 604392., 610800., 617208., 623616.,
      606948., 613392., 619836., 626280., 609504., 615984., 622464., 628944.,
      612060., 618576., 625092., 631608., 614616., 621168., 627720., 634272.,
      617172., 623760., 630348., 636936., 619728., 626352., 632976., 639600.,
      622284., 628944., 635604., 642264., 624840., 631536., 638232., 644928.,
      647844., 654864., 661884., 668904., 650400., 657456., 664512., 671568.,
      652956., 660048., 667140., 674232., 655512., 662640., 669768., 676896.,
      658068., 665232., 672396., 679560., 660624., 667824., 675024., 682224.,
      663180., 670416., 677652., 684888., 665736., 673008., 680280., 687552.,
      668292., 675600., 682908., 690216., 670848., 678192., 685536., 692880.,
      673404., 680784., 688164., 695544., 675960., 683376., 690792., 698208.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292200., 351015., 292650.,
                                         354690., 425754., 354690.,
                                         292650., 351015., 292200.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75792., 76968., 78144., 82848., 84024.,
                                         85200., 89904., 91080., 92256.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580575., 584400., 697395., 702030., 581400., 585300.,
      704520., 709380., 845622., 851508., 704430., 709380.,
      581025., 585300., 696855., 702030., 580050., 584400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149304., 151584., 151608., 153936., 153912., 156288.,
      163128., 165696., 165432., 168048., 167736., 170400.,
      176952., 179808., 179256., 182160., 181560., 184512.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1157325., 1161150., 1164975., 1168800., 1390155., 1394790.,
      1399425., 1404060., 1158900., 1162800., 1166700., 1170600.,
      1404180., 1409040., 1413900., 1418760., 1685358., 1691244.,
      1697130., 1703016., 1403910., 1408860., 1413810., 1418760.,
      1157775., 1162050., 1166325., 1170600., 1388535., 1393710.,
      1398885., 1404060., 1155750., 1160100., 1164450., 1168800.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296328., 298608., 300888., 303168., 300888., 303216., 305544., 307872.,
      305448., 307824., 310200., 312576., 323688., 326256., 328824., 331392.,
      328248., 330864., 333480., 336096., 332808., 335472., 338136., 340800.,
      351048., 353904., 356760., 359616., 355608., 358512., 361416., 364320.,
      360168., 363120., 366072., 369024.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580050., 584400., 696855., 702030., 581025., 585300.,
      704430., 709380., 845622., 851508., 704520., 709380.,
      581400., 585300., 697395., 702030., 580575., 584400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150408., 151584., 152760., 153936., 155112., 156288.,
      164520., 165696., 166872., 168048., 169224., 170400.,
      178632., 179808., 180984., 182160., 183336., 184512.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1152525., 1160100., 1161150., 1168800., 1384530., 1393710.,
      1394790., 1404060., 1154325., 1162050., 1162800., 1170600.,
      1399230., 1408860., 1409040., 1418760., 1679580., 1691244.,
      1691244., 1703016., 1399230., 1409040., 1408860., 1418760.,
      1154325., 1162800., 1162050., 1170600., 1384530., 1394790.,
      1393710., 1404060., 1152525., 1161150., 1160100., 1168800.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296304., 300816., 298608., 303168., 300912., 305520., 303216., 307872.,
      305520., 310224., 307824., 312576., 323952., 329040., 326256., 331392.,
      328560., 333744., 330864., 336096., 333168., 338448., 335472., 340800.,
      351600., 357264., 353904., 359616., 356208., 361968., 358512., 364320.,
      360816., 366672., 363120., 369024.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2297475., 2305050., 2312625., 2320200., 2314650., 2322300., 2329950.,
      2337600., 2759880., 2769060., 2778240., 2787420., 2780310., 2789580.,
      2798850., 2808120., 2300925., 2308650., 2316375., 2324100., 2317800.,
      2325600., 2333400., 2341200., 2788830., 2798460., 2808090., 2817720.,
      2808360., 2818080., 2827800., 2837520., 3347496., 3359160., 3370824.,
      3382488., 3370716., 3382488., 3394260., 3406032., 2788650., 2798460.,
      2808270., 2818080., 2807820., 2817720., 2827620., 2837520., 2300175.,
      2308650., 2317125., 2325600., 2315550., 2324100., 2332650., 2341200.,
      2758800., 2769060., 2779320., 2789580., 2777070., 2787420., 2797770.,
      2808120., 2296425., 2305050., 2313675., 2322300., 2311500., 2320200.,
      2328900., 2337600.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      588096., 592608., 597120., 601632., 592656., 597216., 601776., 606336.,
      597216., 601824., 606432., 611040., 601776., 606432., 611088., 615744.,
      606336., 611040., 615744., 620448., 610896., 615648., 620400., 625152.,
      642816., 647904., 652992., 658080., 647376., 652512., 657648., 662784.,
      651936., 657120., 662304., 667488., 656496., 661728., 666960., 672192.,
      661056., 666336., 671616., 676896., 665616., 670944., 676272., 681600.,
      697536., 703200., 708864., 714528., 702096., 707808., 713520., 719232.,
      706656., 712416., 718176., 723936., 711216., 717024., 722832., 728640.,
      715776., 721632., 727488., 733344., 720336., 726240., 732144., 738048.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1155750., 1160100., 1164450., 1168800., 1388535., 1393710.,
      1398885., 1404060., 1157775., 1162050., 1166325., 1170600.,
      1403910., 1408860., 1413810., 1418760., 1685358., 1691244.,
      1697130., 1703016., 1404180., 1409040., 1413900., 1418760.,
      1158900., 1162800., 1166700., 1170600., 1390155., 1394790.,
      1399425., 1404060., 1157325., 1161150., 1164975., 1168800.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      299640., 300816., 301992., 303168., 304344., 305520., 306696., 307872.,
      309048., 310224., 311400., 312576., 327864., 329040., 330216., 331392.,
      332568., 333744., 334920., 336096., 337272., 338448., 339624., 340800.,
      356088., 357264., 358440., 359616., 360792., 361968., 363144., 364320.,
      365496., 366672., 367848., 369024.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2296425., 2311500., 2305050., 2320200., 2313675., 2328900., 2322300.,
      2337600., 2758800., 2777070., 2769060., 2787420., 2779320., 2797770.,
      2789580., 2808120., 2300175., 2315550., 2308650., 2324100., 2317125.,
      2332650., 2325600., 2341200., 2788650., 2807820., 2798460., 2817720.,
      2808270., 2827620., 2818080., 2837520., 3347496., 3370716., 3359160.,
      3382488., 3370824., 3394260., 3382488., 3406032., 2788830., 2808360.,
      2798460., 2818080., 2808090., 2827800., 2817720., 2837520., 2300925.,
      2317800., 2308650., 2325600., 2316375., 2333400., 2324100., 2341200.,
      2759880., 2780310., 2769060., 2789580., 2778240., 2798850., 2787420.,
      2808120., 2297475., 2314650., 2305050., 2322300., 2312625., 2329950.,
      2320200., 2337600.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      590304., 599280., 592608., 601632., 594912., 603984., 597216., 606336.,
      599520., 608688., 601824., 611040., 604128., 613392., 606432., 615744.,
      608736., 618096., 611040., 620448., 613344., 622800., 615648., 625152.,
      645600., 655728., 647904., 658080., 650208., 660432., 652512., 662784.,
      654816., 665136., 657120., 667488., 659424., 669840., 661728., 672192.,
      664032., 674544., 666336., 676896., 668640., 679248., 670944., 681600.,
      700896., 712176., 703200., 714528., 705504., 716880., 707808., 719232.,
      710112., 721584., 712416., 723936., 714720., 726288., 717024., 728640.,
      719328., 730992., 721632., 733344., 723936., 735696., 726240., 738048.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4577775., 4592850., 4607925., 4623000., 4594950., 4610100., 4625250.,
      4640400., 4612125., 4627350., 4642575., 4657800., 4629300., 4644600.,
      4659900., 4675200., 5499330., 5517600., 5535870., 5554140., 5519760.,
      5538120., 5556480., 5574840., 5540190., 5558640., 5577090., 5595540.,
      5560620., 5579160., 5597700., 5616240., 4584975., 4600350., 4615725.,
      4631100., 4601850., 4617300., 4632750., 4648200., 4618725., 4634250.,
      4649775., 4665300., 4635600., 4651200., 4666800., 4682400., 5558130.,
      5577300., 5596470., 5615640., 5577660., 5596920., 5616180., 5635440.,
      5597190., 5616540., 5635890., 5655240., 5616720., 5636160., 5655600.,
      5675040., 6671772., 6694992., 6718212., 6741432., 6694992., 6718320.,
      6741648., 6764976., 6718212., 6741648., 6765084., 6788520., 6741432.,
      6764976., 6788520., 6812064., 5558130., 5577660., 5597190., 5616720.,
      5577300., 5596920., 5616540., 5636160., 5596470., 5616180., 5635890.,
      5655600., 5615640., 5635440., 5655240., 5675040., 4584975., 4601850.,
      4618725., 4635600., 4600350., 4617300., 4634250., 4651200., 4615725.,
      4632750., 4649775., 4666800., 4631100., 4648200., 4665300., 4682400.,
      5499330., 5519760., 5540190., 5560620., 5517600., 5538120., 5558640.,
      5579160., 5535870., 5556480., 5577090., 5597700., 5554140., 5574840.,
      5595540., 5616240., 4577775., 4594950., 4612125., 4629300., 4592850.,
      4610100., 4627350., 4644600., 4607925., 4625250., 4642575., 4659900.,
      4623000., 4640400., 4657800., 4675200.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1171632., 1180608., 1189584., 1198560., 1176192., 1185216., 1194240.,
      1203264., 1180752., 1189824., 1198896., 1207968., 1185312., 1194432.,
      1203552., 1212672., 1189872., 1199040., 1208208., 1217376., 1194432.,
      1203648., 1212864., 1222080., 1198992., 1208256., 1217520., 1226784.,
      1203552., 1212864., 1222176., 1231488., 1208112., 1217472., 1226832.,
      1236192., 1212672., 1222080., 1231488., 1240896., 1217232., 1226688.,
      1236144., 1245600., 1221792., 1231296., 1240800., 1250304., 1281072.,
      1291200., 1301328., 1311456., 1285632., 1295808., 1305984., 1316160.,
      1290192., 1300416., 1310640., 1320864., 1294752., 1305024., 1315296.,
      1325568., 1299312., 1309632., 1319952., 1330272., 1303872., 1314240.,
      1324608., 1334976., 1308432., 1318848., 1329264., 1339680., 1312992.,
      1323456., 1333920., 1344384., 1317552., 1328064., 1338576., 1349088.,
      1322112., 1332672., 1343232., 1353792., 1326672., 1337280., 1347888.,
      1358496., 1331232., 1341888., 1352544., 1363200., 1390512., 1401792.,
      1413072., 1424352., 1395072., 1406400., 1417728., 1429056., 1399632.,
      1411008., 1422384., 1433760., 1404192., 1415616., 1427040., 1438464.,
      1408752., 1420224., 1431696., 1443168., 1413312., 1424832., 1436352.,
      1447872., 1417872., 1429440., 1441008., 1452576., 1422432., 1434048.,
      1445664., 1457280., 1426992., 1438656., 1450320., 1461984., 1431552.,
      1443264., 1454976., 1466688., 1436112., 1447872., 1459632., 1471392.,
      1440672., 1452480., 1464288., 1476096.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}